精华内容
下载资源
问答
  • 下列 Python语句的输出结果是
    千次阅读
    2021-02-11 17:44:18

    【填空题】遍历输出文件所有行。 f=open("d:\\r2.txt","r") while True: str= print(str,end='') if not str: break f.close()

    【填空题】Pyhon语句序列"s1= 'red hat'; print(str.upper(s1))”的运行结果是?

    【单选题】下列语句中, ( ) 在 Python 中是非法的。

    【单选题】执行下列 Python语句将产生的结果是( ) i=1 if (i): print(True) else: print( False)

    【单选题】下列与数学表达式 对应的 Python表达式不正确的是?

    【填空题】.循环语句 for i in range(-3,21,4)的循环次数为( )

    【填空题】在 Python中要表示一个空的代码块,可以使用( )作为空语句?

    【填空题】程序填空题 以下程序可把水仙花数(即3位正整数中各位数字立方和等于该数本身)装入数组中,然后依次输出,请填空。 #include int main() { int x,y,z,a[10],m,i=0; printf("水仙花数:\n"); for( (1) ;m<1000;m++){ x=m/100; y= (2) ; z=m%10; if(m==x*x*x+y*y*y+z*z*z){ (3) ; } } for(x=0;x

    【填空题】在Python中,设有s='a,b,c'、s2=('x','y','z')以及s3=':',则s. split(','))的结果?

    【单选题】用语句表示如下分段函数f(x),下面程序不正确的是( ) 2x+1 x 1 f(x)= 3x/(x-1) x<1

    【填空题】Python语句re. sub( 'hard', 'easy', 'Python is hard to learn.')的执行结果

    【单选题】Python语句序列“f1= lambda x:x*2; f2= lambda x:x**2; print(f1(f2(2)))”的运行结果是

    【单选题】下面的if语句统计満足“性别( gender)为男、职称(rank)为教授、年龄(age)小于40岁”条件的人数,正确的语句为( )

    【单选题】下 列语句打开文件的位置应该在( )。 f=open('itheima.txt', 'w')

    【单选题】4.5/2=?

    【填空题】打开文件对文件进行读写,操作完成后应该调用( )方法关闭文件,以释放资源。

    【单选题】Python语句 print(type(1/2)的输出结果是

    【填空题】下列Python语句的程序运行结果为: class account: def __init__(self, id, balance): self.id=id self.balance=balance def deposit(self, amount): self.balance += amount def withdraw(self, amount): self.balance-=amount accl=account('1234', 100) accl.deposit(500) accl.withdraw(200) print(accl.balance)

    【填空题】判断值是否为某个类型使用( )函数。(只写函数名)

    【判断题】如有下面代码,输出的结果是一个元组 def f(a,b,c): print(a,b,c) f(*(1,2,3))

    【单选题】下面的程序段求x和y两个数中的大数,( )是不正确的。

    【单选题】在 Python中,若有def f1(a,b,c):pint(a+b),则语句序列“nums=(1,2,3); f1(*nums)”的运行结果是

    【填空题】下列Python语句的程序运行结果为: class Account: def __init__ (self, id): self.id=id id = 888 acc=Account(100) print(acc.id)

    【单选题】以下关于异常处理 try 语句块的说法 , 不正确的是 ( ) 。

    【填空题】Python表达式eval("5/2+5%2+5//2")的结果是

    【填空题】在Python中,设有s='a,b,c'、s2=('x','y','z')以及s3=':',则s. rsplit(',', 1)的结果?

    【填空题】下列 Python语句的运行结果为 x =False: y =True; z=False if x or y and z: print("yes") else: print("no")

    【填空题】在打开随机文件后,可以使用实例方法( )进行定位。

    【填空题】使用readlines方法把整个文件中的内容进行一次性读取,返回的是一个( )。

    【填空题】程序填空题 打印以下杨辉三角形,请填空。(要求打印出10行) 1 11 121 1331 14641 ...... #include int main() { int a[10][10],i,j; for(i=0;i<10;i++){ (1) ; (2) ; } for(i=2;i<10;i++) for(j=1;j

    【填空题】Pyhon语句序列"s1= 'red hat'; print(str.swapcase(s1))”的运行结果是?

    【填空题】下列 Python语句的输出结果是 def judge( param,*param2): print(param2) judge(1,2,3,4,5)

    【填空题】将读取的内容写入到文件中。 with open('test.txt', 'r') as src,open('test_new.txt', 'w') as dst: dst.write( )

    【单选题】在 Python中,若有def f1(p,**p2): print(type(p2)),则f1(1,a=2)的运行结果是

    【单选题】如要将x的十位和个位交换(如13变为31),以下正确的是?

    【判断题】Python 中的标识符不能使用关键字。( )

    【填空题】使用( )方法可以返回指针的当前位置。( )

    【单选题】在 Python中如果语句太长,可以使用( )作为续行符?

    【填空题】在 Python 中, int 表示的数据类型是 _________ 。

    【单选题】Python语句 print(type([1,2,3,4])的运行结果是

    【单选题】print(r"\nGood")的结果是

    【填空题】下列 Python语句的输出结果是 def judge( param,**param2): print(param2) judge(1,a=2,b=3,c=4,d=5)

    【填空题】Python语句“ for i in range(10,1,-2): print(i,end='-')”的输出结果为( )

    【单选题】Python语句 print(type(1J))的输出结果是

    【填空题】Python语句re. split('\W+','go, went, gone')的执行结果是

    【判断题】标识符可以以数字开头。( )

    【填空题】Python 语言采用结构化的异常处理机制。在程序运行过程中如果产生错误,则抛出异常 ; 通过 ( ) 语句来定义代码块 , 以运行可能抛出异常的代码;通过 ( ) 语句可以捕获特定的异常并执行相应的处理;通过 ( ) 语句可以保证即使产生异常 ( 处理失败 ) ,也可以在事后清理资源等。

    【单选题】Python语句 print(type(1,2,3,4))的运行结果是

    【填空题】Python 可以使用函数( )打开文件。

    【填空题】文件操作可以使用( )保证系统自动关闭打开的流。

    更多相关内容
  • 第15章 Java的输入输出流对于任何编程语言处理数据的输入输出操作都占有极其重要的地位Java语言以流的形式进行数据的输入输出处理这一章我们将为大家详细讲述输入输出流的概念文件的概念以及字节的输入输出流和字符...
  • 7.1 Java语言I/O的类层次 Java输入/输出流封装在包java.io中其常用的层次结构如图7.17.2所示 除了图中给出的类外实际使用中我们还会碰到File类它用来描述某个文件的信息输入/输出类中还有几个比较重要的接口例如...
  • Java输入输出流详解

    千次阅读 2021-02-26 09:14:45
    通过数据、序列化和文件系统提供系统输入和输出。Java把这些不同来源和目标的数据都统一抽象为数据。Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要...

    通过数据流、序列化和文件系统提供系统输入和输出。

    Java把这些不同来源和目标的数据都统一抽象为数据流。Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。

    在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流。

    1.1、Java流的分类

    按流向分:

    输入流: 程序可以从中读取数据的流。

    输出流: 程序能向其中写入数据的流。

    按数据传输单位分:

    字节流: 以字节为单位传输数据的流

    字符流: 以字符为单位传输数据的流

    按功能分:

    节点流: 用于直接操作目标设备的流

    过滤流: 是对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能。

    1.2、java.io常用类

    JDK所提供的所有流类位于java.io包中,都分别继承自以下四种抽象流类:

    InputStream:继承自InputStream的流都是用于向程序中输入数据的,且数据单位都是字节(8位)。

    OutputSteam:继承自OutputStream的流都是程序用于向外输出数据的,且数据单位都是字节(8位)。

    Reader:继承自Reader的流都是用于向程序中输入数据的,且数据单位都是字符(16位)。

    Writer:继承自Writer的流都是程序用于向外输出数据的,且数据单位都是字符(16位)。

    java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往需要包装许多不同的对象。在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流....本文的目的是为大家做一个简要的介绍。

    流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样,如下图:

    0_1307609601B32I.gif

    0_1307609529LtvQ.gif

    Java中的流分为两种,一种是字节流,另一种是字符流,分别由四个抽象类来表示(每种流包括输入和输出两种所以一共四个):InputStream,OutputStream,Reader,Writer。Java中其他多种多样变化的流均是由它们派生出来的:

    stream代表的是任何有能力产出数据的数据源,或是任何有能力接收数据的接收源。在Java的IO中,所有的stream(包括Inputstream和Out stream)都包括两种类型:

    (1)字节流

    表示以字节为单位从stream中读取或往stream中写入信息,即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据,如图象和声音。

    (2)字符流

    以Unicode字符为导向的stream,表示以Unicode字符为单位从stream中读取或往stream中写入信息。

    区别:

    Reader和Writer要解决的,最主要的问题就是国际化。原先的I/O类库只支持8位的字节流,因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode字符),这样加了Reader和Writer之后,所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。

    但是,Read和Write并不是取代InputStream和OutputStream,有时,你还必须同时使用"基于byte的类"和"基于字符的类"。为此,它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader,而OutputStreamWriter则将OutputStream转化成Writer。

    一.流的层次结构

    定义:

    (1)       java将读取数据对象成为输入流,能向其写入的对象叫输出流。结构图如下:

    0_13076105077750.gif

    输入流

    0_13076106948usp.gif

    输出流

    二.InputStream类

    inputstream类和outputstream类都为抽象类,不能创建对象,可以通过子类来实例化。

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

    (1)       public abstract int read( ):读取一个byte的数据,返回值是高位补0的int类型值。

    (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( ) :我们在使用完后,必须对我们打开的流进行关闭.

    三.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( ) : 关闭输出流并释放与流相关的系统资源。

    注意:

    1. 上述各方法都有可能引起异常。

    2. InputStream和OutputStream都是抽象类,不能创建这种类型的对象。

    四.FileInputStream类

    FileInputStream类是InputStream类的子类,用来处理以文件作为数据输入源的数据流。使用方法:

    方式1:

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

    FileInputStream in=new FileInputStream(fin);

    方式2:

    FileInputStream in=new

    FileInputStream("d: /abc.txt");

    方式3:

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

    FileDescriptor() fd=new FileDescriptor();

    FileInputStream f2=new FileInputStream(fd);

    五.FileOutputStream类

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

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

    方式1:

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

    FileOutputStream out=new FileOutputStream (f);

    方式2:

    FileOutputStream out=new

    FileOutputStream("d:/abc.txt");

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

    FileDescriptor() fd=new FileDescriptor();

    FileOutputStream f2=new FileOutputStream(fd);

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

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

    注意:

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

    举例:2-1

    六.File类

    File类与InputStream / OutputStream类同属于一个包,它不允许访问文件内容。

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

    举例:2-2

    七.从一个流构造另一个流

    java的流类提供了结构化方法,如,底层流和高层过滤流。

    而高层流不是从输入设备读取,而是从其他流读取。同样高层输出流也不是写入输出设备,而是写入其他流。

    使用"分层对象(layered objects)",为单个对象动态地,透明地添加功能的做法,被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象,都必须具有与之完全相同的接口。这使得decorator的用法变得非常的透明--无论对象是否被decorate过,传给它的消息总是相同的。这也是Java I/O类库要有"filter(过滤器)"类的原因:抽象的"filter"类是所有decorator的基类。Decorator模式常用于如下的情形:如果用继承来解决各种需求的话,类的数量会多到不切实际的地步。Java的I/O类库需要提供很多功能的组合,于是decorator模式就有了用武之地。

    为InputStream和OutputStream定义decorator类接口的类,分别是FilterInputStream和FilterOutputStream。

    FilterInputStream的种类

    功能

    构造函数的参数

    用法

    DataInputStream

    与DataOutputStream配合使用,这样你就能以一种"可携带的方式(portable fashion)"从流里读取primitives了(int,char,long等)

    InputStream

    包含了一整套读取primitive数据的接口。

    BufferedInputStream

    用这个类来解决"每次要用数据的时候都要进行物理读取"的问题。你的意思是"用缓冲区。"

    InputStream,以及可选的缓冲区的容量

    它本身并不提供接口,只是提供一个缓冲区。需要连到一个"有接口的对象(interface object)"。

    LineNumberInputStream

    跟踪输入流的行号;有getLineNumber( )和setLineNumber(int)方法

    InputStream

    只是加一个行号,所以还得连一个"有接口的对象"。

    PushbackInputStream

    有一个"弹压单字节"的缓冲区(has a one byte push-back buffer),这样你就能把最后读到的那个字节再压回去了。

    InputStream

    主要用于编译器的扫描程序。可能是为支持Java的编译器而设计的。用的机会不多。

    FilterOutputStream的种类

    功能

    构造函数的参数

    用法

    DataOutputStream

    与DataInputStream配合使用,这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)

    OutputStream

    包括写入primitive数据的全套接口。

    PrintStream

    负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储,而PrintStream负责数据的显示。

    一个OutputStream以及一个可选的boolean值。这个boolean值表示,要不要清空换行符后面的缓冲区。

    应该是OutputStream对象的最终包覆层。用的机会很多。

    BufferedOutputStream

    用 这个类解决"每次往流里写数据,都要进行物理操作"的问题。也就是说"用缓冲区"。用flush( )清空缓冲区。

    OutputStream, 以及一个可选的缓冲区大小

    本身并不提供接口,只是加了一个缓冲区。需要链接一个有接口的对象。

    DataInputStream类对象可以读取各种类型的数据。

    DataOutputStream类对象可以写各种类型的数据;

    创建这两类对象时,必须使新建立的对象指向构造函数中的参数对象。例如:

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

    DataInputStream din=new DataInputStream(in);

    7.2BufferInputStream和bufferOutputStream

    允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。

    BufferInputstream定义了两种构造函数

    (1)       BufferInputStream b= new BufferInputstream(in);

    (2)       BufferInputStream b=new BufferInputStream(in,size)

    第二个参数表示指定缓冲器的大小。

    同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。

    7.3printstream

    用于写入文本或基本类型

    两种构造函数方法:

    PrintStream ps=new PrintStream(out);

    PrintStream ps=new PrintStream(out, autoflush)

    第二个参数为布尔值,控制每次输出换行符时java是否刷新输出流。

    八.字符流的读取和写入

    java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入16位字符,也就是 Unicode 编码的字符;而 InputStream 用于读入 ASCII 字符和二进制数据。

    0_1307611216sr6D.gif

    Reader 体系结构

    (1)       FileReader

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

    --将文件名作为字符串

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

    --构造函数将File对象作为其参数。

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

    FileReader f1=new FileReader(f);

    --构造函数将FileDescriptor对象作为参数

    FileDescriptor() fd=new FileDescriptor()

    FileReader f2=new FileReader(fd);

    (2)    charArrayReader

    将字符数组作为输入流,构造函数为:

    public CharArrayReader(char[] ch);

    (3)    StringReader

    读取字符串,构造函数如下:

    public StringReader(String s);

    (4)    InputStreamReader

    从输入流读取字节,在将它们转换成字符。

    Public inputstreamReader(inputstream is);

    (5)    FilterReader

    允许过滤字符流

    protected filterReader(Reader r);

    (6)    BufferReader

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

    Public BufferReader(Reader r);

    0_13076114250kKk.gif

    Writer类体系结构

    (1)       FileWrite

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

    Public FileWrite(file f);

    (2)chararrayWrite()

    将字符缓冲器用作输出。

    Public CharArrayWrite();

    (3)    PrintWrite

    生成格式化输出

    public PrintWriter(outputstream os);

    (4)    filterWriter

    用于写入过滤字符流

    protected FilterWriter(Writer w);

    FilterOutputStream的种类

    功能

    构造函数的参数

    用法

    DataOutputStream

    与DataInputStream配合使用,这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)

    OutputStream

    包括写入primitive数据的全套接口。

    PrintStream

    负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储,而PrintStream负责数据的显示。

    一个OutputStream以及一个可选的boolean值。这个boolean值表示,要不要清空换行符后面的缓冲区。

    应该是OutputStream对象的最终包覆层。用的机会很多。

    BufferedOutputStream

    用 这个类解决"每次往流里写数据,都要进行物理操作"的问题。也就是说"用缓冲区"。用flush( )清空缓冲区。

    OutputStream, 以及一个可选的缓冲区大小

    本身并不提供接口,只是加了一个缓冲区。需要链接一个有接口的对象。

    DataInputStream类对象可以读取各种类型的数据。

    DataOutputStream类对象可以写各种类型的数据;

    创建这两类对象时,必须使新建立的对象指向构造函数中的参数对象。例如:

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

    DataInputStream din=new DataInputStream(in);

    7.2BufferInputStream和bufferOutputStream

    允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。

    BufferInputstream定义了两种构造函数

    (1)       BufferInputStream b= new BufferInputstream(in);

    (2)       BufferInputStream b=new BufferInputStream(in,size)

    第二个参数表示指定缓冲器的大小。

    同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。

    7.3printstream

    用于写入文本或基本类型

    两种构造函数方法:

    PrintStream ps=new PrintStream(out);

    PrintStream ps=new PrintStream(out, autoflush)

    第二个参数为布尔值,控制每次输出换行符时java是否刷新输出流

    展开全文
  • 标准输入输出流

    千次阅读 2018-02-04 14:51:01
    提供的标准输出流,它已经事先被包装成了 PrintStream 对象,也就是说 System.out 本质就是 PrintStream ,这一点我们通过看 System 类的源码便知。 public final class System { // ...省略其它源码 ...

     相信很多人在刚开始学习java的时候,使用的第一个语句就是System.out.println("hello world");那时候我们也没多想,照着书上打,然后就奇迹般的在我们机器的显示器上显示了“hello world”,虽然很简单,但是也让我们高兴了好久,自己终于会用java了。。。

     

     然而,或许到现在我们也没有理会System.out到底是什么。其实System.outjava提供的标准输出流,它已经事先被包装成了PrintStream对象,也就是说System.out本质就是PrintStream,这一点我们通过看System类的源码便知。


    public final class System {
    	
    	// ...省略其它源码
    	public final static PrintStream out = null;
    }

     

     既然System.out就是PrintStream那么我们就完全可以像使用PrintStream一样使用System.out


    package com.gk.io.byte_;
    
    import java.io.PrintStream;
    import java.io.PrintWriter;
    
    public class StandardStreamDemo {
    	
    	public static void main(String[] args) {
    		
    		out();
    	}
    	
    	public static void out() {
    		
    		PrintStream ps = System.out;
    		
    		ps.println(47);		// 往控制台输出int类型数据
    		ps.println(13.14);	// 往控制台输出double类型数据
    		ps.println("I love java");	// 往控制台输出string类型数据 			
    		
    	}
    	
    }



     由于System.out是一个PrintStream,而PrintStream是一个OutputStream,也就是说System.out是一个字节流。为了使用起来更加高效快捷,我们完全可以将System.out包装成PrintWriter


    public static void out2() {
    		
    	PrintWriter pw = new PrintWriter(System.out, true);
    		
    	pw.println(47);		// 往控制台输出int类型数据
    	pw.println(13.14);	// 往控制台输出double类型数据
    	pw.println("I love java");	// 往控制台输出string类型数据 	
    		
    }



     使用带有两个参数的PrintWriter构造器,第二个参数设置为true表示开启自动刷新,否则,可能由于输出的数据小于缓冲区的大小而导致数据暂时存放于缓冲区中,从而看不到数据的输出。

     

     System类还有另一个常量in,它就是java提供的标准输入流,不过System.in却是一个没有被包装过的未经加工的InputStream,也就是说在使用System.in之前必须对其进行包装。

     

     通常我们会用readLine()一次一行的读取输入,所以我们可以将System.in包装成BufferedReader,从而实现从控制台的输入。


    public static void in() throws IOException {
    		
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		
    	System.out.print("请输入一个整数 : " );
    	int integer = Integer.parseInt(br.readLine());
    	System.out.println("您输入的整数是 : " + integer);
    	System.out.println();
    	
    	System.out.print("请输入一个小数 : " );
    	double decimal = Double.parseDouble(br.readLine());
    	System.out.println("您输入的小数是 : " + decimal);
    	System.out.println();
    	
    	System.out.print("请输入一个字符串:");
    	String line = br.readLine();
    	System.out.println("您输入的字符串是 : " + line);
    		
    	// 释放资源
    	br.close();
    		
    }


     上面方法虽然也能实现从控制台输入任意类型数据,但是比较麻烦,需要我们自己将字符串解析成任意类型数据,也可能会出现NumberFormatException异常,所以一般我们不这样用。JDK1.5给我们提供了Scanner,我们可以很方便的使用Scanner从控制台输入任意类型数据。


    public static void in2() throws IOException {
    		
    	Scanner sc = new Scanner(System.in);
    		
    	System.out.print("请输入一个整数 : " );
    	int integer = sc.nextInt();
    	System.out.println("您输入的整数是 : " + integer);
    	System.out.println();
    		
    	System.out.print("请输入一个小数 : " );
    	double decimal = sc.nextDouble();
    	System.out.println("您输入的小数是 : " + decimal);
    	System.out.println();
    	
    	System.out.print("请输入一个字符串:");
    	sc.nextLine();
    	String line = sc.nextLine();
    	System.out.println("您输入的字符串是 : " + line);
    	System.out.println();
    		
    	// 释放资源
    	sc.close();
    }


     Scanner提供了两个方法next()nextLine()用于输入字符串。两者的区别如下:

     

     next()方法一定要读取到有效字符后才可以结束输入,对输入有效字符之前遇到的空格键、tab键Enter键等结束符,next()方法会自动将其去掉,只有在输入有效字符之后,next()方法才将其后输入的空格键、tab键或Enter键等视为分隔符或结束符

     

     nextLine()方法的结束符只是Enter键,nextLine()方法返回的是Enter键之前的所有字符,它是可以得到带空格的字符串的。

     

     由于nextLine()可以得到带空格的字符串,所以我们选择用nextLine()方法输入“I love java”,又由于nextLine()遇到Enter键就结束,所以在使用nextLine()时先在前面再使用一次nextLine()以过滤掉nextDouble()后的Enter键。如果nextLine()为第一个输入则不需要这样做。








    展开全文
  • 【Java 输入、输出流

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


    概述:输入、输出流提供一条通道程序,可以使用这条通道读取源中的数据或把数据传送到目的地。把输入流的指向称作源,程序从指向源的输入流中读取源中的数据;而输出流的指向是数据要去的一个目的地,程序通过向输出流中写入数据把数据传送到目的地。

    在这里插入图片描述

    1 File类

    File对象主要用来获取文件本身的一些信息,不涉及对文件的读写操作

    创建一个File对象的构造方法有3个,如下:

    (1) File(String filename);//filename为文件名
    (2) File(String directoryPath,String filename);//directoryPath是文件的路径
    (2) File(File dir,String filename);//dir为一个目录
    

    使用File(String filename);创建文件时,该文件位置默认为当前程序所在位置

    1.1 文件的属性

    File类的下列方法获取文件本身的一些信息。

    public String getName()//获取文件的名字。
    public boolean canRead()//判断文件是否是可读的。
    public boolean canWrite()//判断文件是否可被写入。
    public boolean exits()//判断文件是否存在。
    public long length()//获取文件的长度(单位是字节)。
    public String getAbsolutePath()//获取文件的绝对路径。
    public String getParent()//获取文件的父目录。
    public boolean isFile()//判断文件是否是一个普通文件,而不是目录。
    public boolean isDirectroy()//判断文件是否是一个目录。
    public boolean isHidden()//判断文件是否是隐藏文件。
    public long lastModified()//获取文件最后修改的时间。
    

    例子1.1(例子中使用上述的一些方法,获取某些文件的信息)

    package Example1;
    
    import java.io.File;
    
    public class Example1_1 {
        public static void main(String[] args) {
            File file = new File("D:\\lifeilin", "lifeilin.txt");//创建文件对象
            try {
                file.createNewFile();//创建一个新文件
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("文件是否存在:" + file.exists());
            System.out.println(file.getName() + "是可读的吗:" + file.canRead());
            System.out.println(file.getName() + "的长度:" + file.length());
            System.out.println(file.getName() + "的绝对路径:" + file.getAbsolutePath());
        }
    }
    

    在这里插入图片描述

    1.2 目录

    (1)创建目录
    public boolean mkdir()

    (2)列出目录中的文件

    public String[] list();用字符串形式返回目录下的全部文件。
    public File [] listFiles();File对象形式返回目录下的全部文件。
    public String[] list(FilenameFilter obj)用字符串形式返回目录下的指定类型的所有文件。
    public File [] listFiles(FilenameFilter obj)File对象形式返回目录下的指定类型所有文件。
    

    上述两方法的参数FilenameFilter是一个接口,该接口有一个方法:
    public boolean accept(File dir,String name);

    例子2(Example1_2.java ,FileAccept.java ),例子2列出当前目录(应用程序所在的目录)下全部java文件的名字)

    FileAccept.java

    package Example1_2;
    
    import java.io.*;
    
    public class FileAccept implements FilenameFilter {//FileAccept类实现FilenameFilter接口
        private String extendName;
        public void setExtendName(String s) {
            extendName="."+s;
        }
        public boolean accept(File dir,String name) { //重写接口中的方法
            return name.endsWith(extendName);
        }
    }
    

    Example1_2.java

    package Example1_2;
    
    import java.io.*;
    
    public class Example1_2 {
        public static void main(String[] args) {
            File dirFile = new File(".");
            FileAccept fileAccept = new FileAccept();
            fileAccept.setExtendName("java");
            String fileName[] = dirFile.list(fileAccept);
            for (String name : fileName) {
                System.out.println(name);
            }
        }
    }
    

    1.3 文件的创建与删除

    当使用File类创建一个文件对象后,例如
    File file=new File(“D:”,“letter.txt”);

    如果D:\目录中没有名字为letter.txt文件,文件对象file调用方法
    public boolean createNewFile();
    文件对象调用方法public boolean delete()可以删除当前文件,
    例如:
    file.delete();

    1.4 运行可执行文件

    ➢用Runtime类声明一个对象( Runtime类在java.lang包)
    Runtime ec;
    ➢然后使用该类的getRuntime()静态方法创建这个对象:
    ec=Runtime.getRuntime();
    ec可以调用 exec(String command) 方法打开本地机的可执行
    文件或执行一个操作。

    下面例子演示打开本地的记事本:

    import java.io.*;
    
    public class Example1_4 {
        public static void main(String[] args) {
            try {
                Runtime ce = Runtime.getRuntime();//创建对象
                File file = new File("c:/windows", "Notepad.exe");
                ce.exec(file.getAbsolutePath());//打开本地记事本
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }
    

    2 文件字节输入、输出流

    ➢java.io包提供了大量的流类.
    ➢Java把InputStream 抽象类的子类创建的流对象称作字节输入流;OutputStream抽象类的子类创建的流对象称作字节输出流。
    ➢针对不同的源或目的地。java.io包为程序提供了相应的输入流或输出流。这些输入、输出流绝大部分都是InputStream、OutputStream、Reader或Writer的子类。

    2.1 文件字节输入流

    使用输入流通常包括4个基本步骤:
    (1)设定输入流的源
    (2)创建指向源的输入流
    (3)让输入流读取源中的数据
    (4)关闭输入流。

    (1)构造方法:设定输入流源
    使用FileInputStream类的下列构造方法创建指向文件的输入流。

    FileInputStream(String name);//使用给定的文件名name创建FileInputStream流
    FileInputStream(File file);//使用File对象创建FileInputStream流
    //参数name和file指定的文件称为输入流的源
    

    FileInpuStream输入流打开一个到达文件的通道(源就是这个文件,输入流指向这个文件)。当创建输入流时,可能会出现错误(也被称为异常)。例如,输入流指向的文件可能不存在。当出现I/O错误,Java 生成一个出错信号,它使用IOException (IO异常)对象来表示这个出错信号。程序必须在try-catch语句中的try块部分创建输入流,在catch (捕获)块部分检测并处理这个异常。例如,为了读取一个名为hello.txt 的文件,建立一个文件输入流in。

            try {
                FileInputStream in = new FileInputStream("hello.txt");//创建指向文件hello.txt的输入流
            } catch (IOException e) {
                System.out.println("File read error:" + e);
            }
    

    或者:

    		File f = new File("hello.txt");//指定输入流的源
            try {
                FileInputStream in = new FileInputStream(f);//创建指向源输入流
            } catch (IOException e) {
                System.out.println("File read error:" + e);
            }
    

    (2)使用输入流读取字节
    文件字节流可以调用从父类继承的read方法顺序地读取文件,只要不关闭流,每次调用read方法就顺序地读取文件中的其余内容,直到文件的末尾或文件字节输入流被关闭。

    ➢int read();读取单个字节的数据,返回字节值(0~255整数) ,如果未读出字节就返回-1。
    ➢int read(byte b[]);读取b.length个字节到字节数组b中,返回实际读取的字节数。如果到达文件的末尾,则返回-1。
    ➢int read(byte b[], int off, int len);读取len个字节到字节数组b中,并返回实际读取的字节数目。如果到达文件的末尾,则返回-1,参数off指定从字节数组的某个位置开始存放读取的数据。

    (3) 关闭流
    输入流都提供了关闭方法close(),尽管程序结束时会自动关闭所有的流,但是当程序使用完流后,显示地关闭任何打开的流仍然是一个良好的习惯,如果没有关闭那些被打开的流,那么就可能不允许另一个程序操作这些所用的资源。

    下面例子使用文件字节流读文件内容:

    import java.io.*;
    
    public class Example2_1 {
        public static void main(String[] args) {
            int n = -1;
            byte[] a = new byte[100];
            try {
                File f = new File("D:\\","Example2_1.java");
                InputStream in = new FileInputStream(f);
                while ((n = in.read(a, 0, 100)) != -1) {
                    String s = new String(a, 0, n);
                    System.out.print(s);
                }
                in.close();
            } catch (IOException e) {
                System.out.println("File read Error" + e);
            }
        }
    }
    

    2.2 文件字节输出流

    ➢使用输出流通常包括4个基本步骤:
    (1)给出输出流的目的地
    (2)创建指向目的地的输出流
    (3)让输出流把数据写入到目的地
    (4)关闭输出流。

    (1)构造方法
    使用FileOutputStream类的下列具有刷新功能的构造方法创建指向文件的输出流。

    FileOutputStream(String name);
    FileOutputStream(File file);
    //参数name和file指定的文件称为输出流的目的地
    

    FileOutpuStream输出流开通一个到达文件的通道(目的地就是这个文件,输出流指向这个文件)。需要特别注意的是,如果输出流指向的文件不存在,Java 就会创建该文件,如果指向的文件是已存在的文件,输出流将刷新该文件(使得文件的长度为0)。另外,与创建输入流相同,创建输出流时,可能会出现错误(被称为异常),例如,输出流试图要写入的文件可能不允许操作或有其他受限等原因。所以必须在try-catch语句中的try块部分创建输出流,在catch (捕获)块部分检测并处理这个异常。例如,创建指向名为destin.txt的输出流out。

            try {
                FileOutputStream out = new FileOutputStream("destin.txt");//创建指向文件destin.txt的输出流
            } catch (IOException e) {
                System.out.println("File writeerror:" + e);
            }
    

    或者:

    		File f = new File("destin.txt");//指定输出流的源
            try {
                FileOutputStream out = new FileOutputStream (f);//创建指向源输出流
            } catch (IOException e) {
                System.out.println("File write:" + e);
            }
    

    可以使用FileOutputStream类的下列能选择是否具有刷新功能的构造方法创建指向文件的输出流。

    FileOutputStream(String name, boolean append) ;
    FileOutputStream(File file, boolean append) ;
    

    当用构造方法创建指向一个文件的输出流时,如果参数append取值true, 输出流不会刷新所指向的文件(假如文件已存在),输出流的write的方法将从文件的末尾开始向文件写入数据,参数append取值false, 输出流将刷新所指向的文件(假如文件已存在)。

    (2)使用输出流写字节
    输出流的wirie方法以字节单位向目的地写数据。

    void write(int n)//向目的地写入单个字节。
    void write(byte b[])//向目的地写入一个字节数组。
    void write(byte b[],int off,int len)//从字节数组中偏移量off处取len个字节写到目的地。
    

    FileOutputStream流顺序地写文件,只要不关闭流,每次调用write方法就顺序地向目的地写入内容,直到流被关闭。

    (3)关闭流
    通过调用close()方法,可以保证操作系统把流缓冲区的内容写到它的目的地,即关闭输出流可以把该流所用的缓冲区的内容冲洗掉(通常冲洗到磁盘文件上)。

    例子2.2使用文件字节输出流写文件a.txt。
    例子2.2首先使用具有刷新功能的构造方法创建指向文件a.txt的输出流、并向a.txt文件写入“新年快乐”,然后再选择使用不刷新文件的构造方法指向a.txt,并向文件写入( 即尾加)“ Happy New Year

    import java.io.*;
    
    public class Example2_2 {
        public static void main(String[] args) {
            byte[] a = "新年快乐".getBytes();
            byte[] b = "Happy New Year".getBytes();
            File file = new File("D:\\","a.txt");                         //输出的目的地
            try {
                OutputStream out = new FileOutputStream(file);      //指向目的地的输出流
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");//a.txt的大小:0字节
                out.write(a);                                    //向目的地写数据
                out.close();
                out = new FileOutputStream(file, true);             //准备向文件尾加内容
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");///a.txt的大小:8字节
                out.write(b, 0, b.length);
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");///a.txt的大小:8字节
                out.close();
            } catch (IOException e) {
                System.out.println("Error " + e);
            }
        }
    }
    

    在这里插入图片描述

    3 文件字符输入、输出流

    ➢Java把Reader抽象类的子类创建的流对象称作字符输入流;Writer抽象类的子类创建的流对象称作字符输出流。

    与FileInputStream. FileOutputStream字节流相对应的是FileReader、FileWriter字符流(文件字符输入、输出流),FileReader 和FileWriter 分别是Reader和Writer的子类,其构造方法分别是:

    FileReader(String filename) ; 
    FileReader(File filename) ;
    
    FileWriter(String filename) ; 
    FileWriter(File filename) ;
    FileWriter(String filename, boolean append) ; 
    FileWriter(File filename,boolean append) ;
    

    字符输入流和输出流的read和write方法使用字符数组读写数据,即以字符为基本单位处理数据。

    ➢1. Reader类提供的read方法以字符为单位顺序地读取源中的数据。

    int read();
    int read(char b[]);
    int read(char b[], int off, int len);
    void close();
    

    ➢2. Writer流 以字符为单位顺序地写文件,每次调用write方法就顺序地向目的地写入内容。Writer类有 如下常用的方法。

    void write(int n)//向输出流写入一个字符。
    void write(byte b[])//向输出流写入一个字符数组。
    void write(byte b[],int off,int length)//从给定字符数组中起始于偏移量off处取len个字符写到输出流。
    void close()//关闭输出流。
    

    例子3使用文件字符输入、输出流将文件a.txt的内容尾加到文件b.txt中

    import java.io.*;
    
    public class Example3 {
        public static void main(String args[]) {
            File sourceFile = new File("a.txt");  //读取的文件
            File targetFile = new File("b.txt");  //写入的文件
            char c[] = new char[19];               //char型数组
            try {
                Writer out = new FileWriter(targetFile, true); //指向目的地的输出流
                Reader in = new FileReader(sourceFile);   //指向源的输入流
                int n = -1;
                while ((n = in.read(c)) != -1) {
                    out.write(c, 0, n);
                }
                out.flush();
                out.close();
            } catch (IOException e) {
                System.out.println("Error " + e);
            }
        }
    }
    

    注:对于Writer流,write 方法将数据首先写入到缓冲区,每当缓冲区溢出时,缓冲区的内容被自动写入到目的地,如果关闭流,缓冲区的内容会立刻被写入到目的地。流调用flush0方法可以立刻冲洗当前缓冲区,即将当前缓冲区的内容写入到目的地。

    4 缓冲流

    ➢BufferedReader和BufferedWriter类创建的对象称作缓冲输入、输出流。二者的源和目的地必须是字符输入流和字符输出流。
    ➢构造方法:

    BufferedReader(Reader in);
    BufferedWriter(Writer out);
    

    BufferedReader流能够读取文本行,方法是readLine()。通过向BufferedReader 传递一个Reader子类的对象(如FileReader 的实例),来创建一个BufferedReader对象,如:

    FileReader inOne = new FileReader("Student. txt") ;
    BufferedReader inTwo = BufferedReader(inOne) ;
    

    然后inTwo流调用readLine()方法中读取Student.txt,例如:

    String strLine = inTwo. readLine() ;
    

    类似地,可以将BufferedWriter流和FileWriter 流连接在一起, 然后使用BufferedWriter流将数据写到目的地,例如:

    FileWriter tofile = new FileWriter("hello.txt") ;
    BufferedWriter out = BufferedWriter(tofile) ;
    

    然后out使用BufferedReader类的方法wite(tring s,int off,int len)把字符串s写到hello.txt中,参数off是s开始处的偏移量,len是写入的字符数量。
    另外,BufferedWriter 流有-一个独特的向文件写入一 个回行符的方法

    newLine() ;

    ➢BufferedReader和BufferedWriter类读 写文件的方法:

    readLine()//读取文本行
    write(String s,int of,int len)//把字符串s写到文件中
    newLine();// 向文件写入一个回行符
    

    由英语句子构成的文件english. txt (每句占一行):
    The arrow missed the target.
    They rejected the union demand.
    Where does this road go to?

    例子4按行读取english. txt,并在该行的后面尾加上该英语句子中含有的单词数目,然后再将该行写入到一个名字为englishCount. txt的文件中

    import java.io.*;
    import java.util.*;
    
    public class Example10_1 {
        public static void main(String[] args) {
            File fRead = new File("D:\\","english.txt");
            File fWrite = new File("D:\\","englishCount.txt");
            try {
                Writer out = new FileWriter(fWrite);//指向目的地的输出流
                BufferedWriter bufferWrite = new BufferedWriter(out);
    
                Reader in = new FileReader(fRead);//指向源的输入流
                BufferedReader bufferRead = new BufferedReader(in);
    
                String str = null;
                while ((str = bufferRead.readLine()) != null) {
                    StringTokenizer fenxi = new StringTokenizer(str);
                    int count = fenxi.countTokens();
                    str = str + " 句子中单词个数:" + count;
                    bufferWrite.write(str);
                    bufferWrite.newLine();
                }
                bufferWrite.close();
                out.close();
                in = new FileReader(fWrite);
                bufferRead = new BufferedReader(in);
                String s = null;
                System.out.println(fWrite.getName() + "内容:");
                while ((s = bufferRead.readLine()) != null) {
                    System.out.println(s);
                }
                bufferRead.close();
                in.close();
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • public static final PrintStream out:标准输出流。通常该流对应于显示输出或者由主机环境或用户指定的另一个输出目标 我们先看标准输入流 package com.testIO; import java.io.IOException; import java...
  • java输入、输出流的简单入门

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

    2020-06-03 15:37:19
    5.标准输入输出流 标准的输入输出流简单了解一下就可以了,实际开发时一般用不着。 标准的输入流 System.in表示标准的输入流,用来从读取从键盘录入的数据,本质上就是一个InputStream 看下面代码演示,从键盘录入...
  • Java中的输入/输出流

    千次阅读 2019-03-23 16:33:27
    Java中包含的输入/输出流类 1.java.io包中的接口 (1)处理字节流的有DataInput接口和DataOutput接口,RandomAccessFile同时实现了这两个接口; (2)处理对象流的有ObjectInput接口和ObjectOutput接口,...
  • 题目: 下面那个流类输出面向字符的输入流() A、BufferedWriter B、FileInputStream C、ObjectInputStream D、InputStreamReader ...输入流和输出流是相对于内存而言,那从磁盘中读取的流肯定是输入流了,所以Rea
  • 字节 输入输出流 byte

    万次阅读 2017-03-03 22:14:27
    输出流: 数据从程序流到外面第二: 从流结构上:其实底层都是以字节流来实现的。 **字节流: 字符流**:在字节流的基础上做了封装,相当于直接操作字符串一样,简化操作。字节流**byte Stream的输入和输出基础是...
  • java.io.OutputStream抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。 public void close() :关闭此输出流并释放与此流相关联的任何系统资源。 ...
  • C语言中的输入输出流和缓冲区(重点)详解

    万次阅读 多人点赞 2019-01-01 13:21:56
    C语言中我们用到的最频繁的输入输出方式就是scanf()与printf()。 scanf(): 从标准输入设备(键盘)读取数据,并将值存放在变量中。 printf(): 将指定的文字/字符串输出到标准输出设备(屏幕)。注意宽度输出和精度 ...
  • 文件输出流:FileOutputStream

    千次阅读 2020-03-29 11:11:18
    java.io.FileOutputStream类是文件输出流,用于将数据写出到文件。 1. 构造方法 public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。 public FileOutputStream(String name):...
  • C++ 流 文件操作(输入输出流

    万次阅读 多人点赞 2018-09-26 20:37:15
    到目前为止,我们已经使用了 iostream 标准库,它提供了 cin 和 cout 方法分别用于从标准输入读取和向标准输出写入。 本教程介绍如何从文件读取和向文件写入。这就需要用到 C++ 中另一个标准库 fstream,它...
  • 1.1 标准输入输出流 public static final InputStream in:标准输入流 public static final PrintStream out:标准输出流 OutputStreamWriter:将字节输出流转换为字符输出流 public class ...
  • C++输入输出文件

    千次阅读 2020-02-12 20:40:38
    标准输出流(cout) 预定义的对象 cout 是 iostream 类的一个实例。cout 对象“连接”到标准输出设备,通常是显示屏。cout 是与流插入运算符 << 结合使用的。 标准输入流(cin) 预定义的对象 cin 是 iostream...
  • c++ 选择题复习目录 大一下学期:点击...在下列流类中,可以用于处理文件的是( D )。(A)ios (B)iostream (C)strstream (D)fstream2.在下列选项中,( B )是istream类的对象。(A)cerr (B)cin ...
  • JAVA实验六 输入输出流

    千次阅读 2020-12-31 14:52:10
    理解文件和的概念、Java 的层次结构,掌握 Java 提供的各种字节类和字符类的功能和使用方法。 实验内容: 1、编写一个 Java 应用程序,将已存在的扩展名为.txt 的文本文件加密后存入另一个文本文件中。按...
  • IO —— 标准输入流和标准输出流

    千次阅读 2016-07-24 08:26:33
    这一节讲解标准输入流和标准输出流。例1:示例了 syso 或者 sout 的深层道理,其实就是 PrintStream/** * Created by liwei on 16/7/19. */ /* * System.in 标准输入流。是从键盘获取数据的 * * 键盘录入数据的...
  • 下列代码运行结果是?

    千次阅读 2021-01-30 18:43:18
    【单选题】下列各项中,不属于财务报表审计的前提条件的是( )。 【单选题】【图片】 【单选题】【图片】 【填空题】请写出名词wife的复数形式 【单选题】当你很久没有运动,在上完一次体育课或进行过一次大的运动...
  • Java 输入输出(含部分答案)

    千次阅读 2021-03-18 10:33:49
    C、catch(Exception e)不能捕获异常抛出的任何类型 D、非GUI程序产生异常时,若没有合适的异常处理与之匹配,则程序将恢复正常的运行 31、下列选项中,哪一个属于输出流?( ) A、从打印机流向控制器的数据流 B、从...
  • C#OOP 之九 文件输入输出流

    千次阅读 2016-04-28 19:10:18
    的概念 是一个抽象的概念,它相当于日常生活中“”的概念,什么意思呢?比如说有河里的水,管道中的石油,电网中的电流等。 C#采用模型读写文件里的数据。这是一种非常经典的文件读取方式,在很多高级语言...
  • 【单选题】1869年,艾耶父子广告公司在( )创建,成为第一家现代意义上的广告代理公司,也标志着广告产业的形成。【单选题】用360浏览器下载杀毒软件,...【判断题】预收账款属于资产类,预付账款属于负债类。【单选题】...
  • 缓冲

    千次阅读 2019-06-14 10:06:37
    BufferedOutputStream ————字节缓冲输出流 继承自父类的共性方法 public void close()——关闭此输出流并释放与此流相关联的任何系统资源。 public void flush()——刷新此输出流并强制任何缓冲的输出字节...
  • A、在Java中,文件的输入输出功能是通过来实现的 B、如果要把数据写入到一个文件中,需要创建一个输入对象 C、字符在某些方面比如汉字的处理,比字节更高效 D、可以通过Reader r = new Reader(“c:\A.txt”)...
  • 1.下面哪个属于面向字符的输入()选择一项)A. BufferedWriterB. FileInputStreamC. ObjectInputStreamD. InputStreamReader答案:D分析:A:字符输出的缓冲B:字节输入C:对象输入2.要从文件”file.dat”...
  • JavaIO DataOutputStream数据输出流

    千次阅读 2018-05-12 20:22:26
    数据输出流允许应用程序以与机器无关方式将Java基本数据类型写到底层输出流。1.字段:protected int written // 到目前为止写入数据输出流的字节数。 2.构造方法:DataOutputStream(OutputStream out) //创建一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,195
精华内容 29,278
关键字:

下列属于输出流的是