java中输入输出的总括(初学必看)
java笔试编程题输入输出处理
![java笔试编程题输入输出处理](https://img.taocdn.com/s3/m/cefc3cef29ea81c758f5f61fb7360b4c2e3f2ae3.png)
Java笔试编程题输入输出处理1. 概述编程题的输入输出处理是Java编程中非常重要的一部分。
在笔试中,通常会给出一个具体的问题,要求我们编写代码实现相应的功能,并处理输入和输出。
本文将介绍Java编程题中输入输出处理的基本知识和常见的处理方法,帮助读者更好地应对Java笔试编程题。
2. 输入处理在编程题中,输入通常以标准输入的形式给出。
标准输入是指从键盘输入数据。
我们需要编写代码来读取这些输入数据,并进行相应的处理。
Java提供了Scanner类来方便地读取标准输入。
以下是一个示例代码:import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 读取整数int num = scanner.nextInt();// 读取字符串String str = scanner.next();// 读取一行字符串String line = scanner.nextLine();// 读取浮点数double decimal = scanner.nextDouble();// 读取布尔值boolean flag = scanner.nextBoolean();// 其他操作...scanner.close();}}在以上示例代码中,我们使用Scanner类的不同方法来读取不同类型的数据。
nextInt()用于读取整数,next()用于读取字符串,nextLine()用于读取一行字符串,nextDouble()用于读取浮点数,nextBoolean()用于读取布尔值。
需要注意的是,使用nextLine()方法读取一行字符串时,可能会出现读取不完整的情况。
这是因为nextLine()会读取一行中的所有字符,包括换行符。
如果在读取前面的数据时使用了其他next()方法,那么换行符可能会被留在缓冲区中,导致nextLine()读取到的是一个空字符串。
JAVA输入输出(IO)系统介绍
![JAVA输入输出(IO)系统介绍](https://img.taocdn.com/s3/m/3f4ce60f1fb91a37f111f18583d049649b660e23.png)
JAVA输入输出(IO)系统介绍在Java编程世界中,输入输出(IO)系统扮演着至关重要的角色。
无论是读取外部文件、控制台输入还是网络数据传输,IO系统都是不可或缺的一部分。
让我们一起来深入了解Java中的IO系统吧!输入输出流在Java中,IO流是处理输入输出数据的重要方式。
输入输出流表示与物理设备(如文件、网络连接、内存等)之间的数据流动。
Java提供了丰富的IO类来支持不同类型的数据读写操作,其中最常用的是InputStream 和OutputStream,以及它们的派生类。
输入流(InputStream)输入流用于从外部源(如文件、网络等)读取数据。
InputStream是所有输入流类的基类,它定义了读取字节的基本方法,如read()。
常用的输入流类包括FileInputStream(从文件读取数据)、ByteArrayInputStream (从字节数组读取数据)等。
输出流(OutputStream)输出流用于向外部目标(如文件、网络等)写入数据。
OutputStream 是所有输出流类的基类,它定义了写入字节的基本方法,如write()。
常用的输出流类包括FileOutputStream(向文件写入数据)、ByteArrayOutputStream(向字节数组写入数据)等。
字符流与字节流Java中的IO流分为字节流和字符流两种类型。
字节流以字节为单位进行读写操作,常用于处理二进制数据;字符流以字符为单位进行读写操作,通常用于处理文本数据。
要注意在使用字符流时,需要考虑字符编码的问题,以避免乱吗问题的出现。
文件读写操作文件IO是Java程序中常见的操作之一。
通过FileInputStream和FileOutputStream可以实现文件的读取和写入。
在进行文件IO操作时,务必注意异常处理和资源释放,以避免文件流无法关闭的问题。
网络IO操作Java的网络编程中,IO也扮演着重要角色。
通过Socket和ServerSocket可以实现基于TCP/IP协议的网络通信。
第三章Java的输入输出
![第三章Java的输入输出](https://img.taocdn.com/s3/m/17a49c46fd4ffe4733687e21af45b307e971f979.png)
数
public class HelloArgs{ public static void main(String args[])
输
{
入
System.out.println( args[0]+","+ args[1]+"
法
Hello!&入输出的应用
例3-6
前一页 休息
例3-1
方
法
前一页 休息
2
标准输入方法
键盘是标准输入设备,用户通常用键盘输入数据。 System类含有标准输入流的成员变量 in,可以调 用它的read方法来读取键盘数据。
public abstract in read( ) //从键盘输入一个字符 public int read(byte[ ] b) //一次输入多个字节数
6
GUI图形界面输入方法示例
例3.7 使用预定义对话框显示一行字符串。 import javax.swing.JOptionPane; //import语句用于加
载类库
public class Welcome6{
public static void main(String args[])
{
JOptionPane.showMessageDialog(null,"Welcome to
本章主要内容
标准输入输出 命令行输入输出应用 流式交互输入输出简单应用 GUI输入输出简单应用
前一页 休息
1
标准输出方法
标
准
输 System类含有标准打印流PrintStream类的成
入 输 出
员变量out,我们可以调用它的print 、println 或 write方法来输出各种类型的数据。
java中输入输出总结
![java中输入输出总结](https://img.taocdn.com/s3/m/8e99296c7ed5360cba1aa8114431b90d6c858907.png)
java中输入输出总结一、数据流的基本概念流一般分为输入流(Input Stream)和输出流(Output Stream)两类,但这种划分并不是绝对的。
比如一个文件,当向其中写数据时,它就是一个输出流;当从其中读取数据时,它就是一个输入流。
当然,键盘只是一个数人流,而屏幕则只是一个输出流。
java的标准数据流:标准输入输出指在字符方式下(如DOS),程序与系统进行交互的方式,分为三种:标准输入studin,对象是键盘。
标准输出stdout,对象是屏幕。
标准错误输出stderr,对象也是屏幕。
二、java.io包中的数据流和文件类字节流:从InputStream和OutputStream派生出来的一系列类。
这类流以字节(byte)为基本处理单位。
InputStream、OutputStreamFileInputStream、FileOutputStreamPipedInputStream、PipedOutputStreamByteArrayInputStream、ByteArrayOutputStreamFilterInputStream、FilterOutputStreamDataInputStream、DataOutputStreamBufferedInputStream、BufferedOutputStream字符流:从Reader和Writer派生出的一系列类,这类流以16位的Unicode码表示的字符为基本处理单位。
Reader、WriterInputStreamReader、OutputStreamWriterFileReader、FileWriterCharArrayReader、CharArrayWriterPipedReader、PipedWriterFilterReader、FilterWriterBufferedReader、BufferedWriterStringReader、StringWriter三、字节流方法InputStream 和OutputStreamread():从流中读入数据skip():跳过流中若干字节数available():返回流中可用字节数mark():在流中标记一个位置reset():返回标记过得位置markSupport():是否支持标记和复位操作close():关闭流int read() :从输入流中读一个字节,形成一个0~255之间的整数返回(是一个抽象方法)。
java输入流总结
![java输入流总结](https://img.taocdn.com/s3/m/20049497b04e852458fb770bf78a6529657d354b.png)
java输入流总结Java输入流是Java中用于读取数据的一种机制。
它提供了一种从数据源(如文件、网络连接、内存等)读取数据的方式。
在Java中,输入流是用于从外部读取数据的,而输出流则是用于向外部写入数据的。
Java中的输入流类位于java.io包中。
常用的输入流类有FileInputStream、BufferedInputStream、DataInputStream等。
下面将对这些输入流进行详细介绍。
1. FileInputStream(文件输入流)FileInputStream是用于从文件中读取数据的输入流。
它可以读取任意类型的文件,包括文本文件、音频文件、图片文件等。
通过创建FileInputStream对象,并指定要读取的文件路径,就可以从文件中读取数据。
可以使用read()方法逐个字节地读取文件内容,也可以使用read(byte[] b)方法一次读取多个字节。
2. BufferedInputStream(缓冲输入流)BufferedInputStream是对InputStream进行了包装,提供了缓冲功能。
它可以提高读取数据的效率,减少对底层资源(如文件)的访问次数。
通过创建BufferedInputStream对象,并将其与具体的输入流(如FileInputStream)进行关联,就可以使用BufferedInputStream读取数据。
3. DataInputStream(数据输入流)DataInputStream是用于读取基本数据类型的输入流。
它可以从输入流中读取Java的基本数据类型(如int、double、boolean等)和字符串等数据。
通过创建DataInputStream对象,并将其与具体的输入流进行关联,就可以使用DataInputStream读取数据。
除了上述常用的输入流类,还有其他一些输入流类,如ObjectInputStream(对象输入流)、PipedInputStream(管道输入流)等。
[java入门学习]第 9 章 Java输入输出操作
![[java入门学习]第 9 章 Java输入输出操作](https://img.taocdn.com/s3/m/606d182c7375a417866f8f58.png)
第九章 Java输入输出操作9.1 Java 输入输出流所有的程序语言都提及与本机文件系统交互的方式;Java也不例外。
我们将看看Java 是怎样处理标准文件输入输出的(包括stdin,stout,stderr)。
当你在网络上开发小程序时,你必须注意直接文件输入输出是不安全因素的关键。
大多数用户设置他们的浏览器,可让你自由的访问他们的文件系统,但有的不让你访问。
当然,如果你开发你内部的应用程序,你也许需要直接访问文件。
标准输入输出Unix的用户,或其他基于命令行系统的用户(如DOS),都知道标准输入输出的含义。
标准输入文件是键盘,标准输出文件是你的终端屏幕。
标准错误输出文件也指向屏幕,如果有必要,它也可以指向另一个文件以便和正常输出区分。
系统类Java通过系统类达到访问标准输入输出的功能。
上面提到的三个文件在这个系统类中实现:Stdin System.in作为InputStream类的一个实例来实现stdin,你可以使用read()和skip(long n)两个成员函数。
read()让你从输入中读一个字节,skip(long n)让你在输入中跳过n个字节。
Stout System.out作为PrintStream来实现stdout,你可以使用print()和println()两个成员函数。
这两个函数支持Java的任意基本类型作为参数。
Stderr System.err同stdout一样实现stderr。
象System.out一样,你可以访问PrintStream 成员函数。
9.2 标准输入输出例子import java.io.* class myCat{public void main(String args[]) throws IOException{int b;int count = 0;while ((b = System.in.read()) != -1){count++;System.out.print((char)b);}System.out.println(); //blank line System.err.println("counted"+count+"total bytes.");}}9.3 普通输入输出类除了基本的键盘输入和屏幕输出外,我们还需要联系文件的输入输出。
Java中常用数据类型的输入输出详解
![Java中常用数据类型的输入输出详解](https://img.taocdn.com/s3/m/ec5959ee710abb68a98271fe910ef12d2af9a93f.png)
Java中常⽤数据类型的输⼊输出详解⽬录1、Char型1.1 输⼊格式:1.2 举例说明2、int型1.1 简单的int格式输⼊:1.2 举例说明2.1带空格的int格式输⼊:2.2 举例说明3.1 复杂int格式的输⼊3.2 举例说明3、double型1.1 double保留两位格式输出1.2 举例说明4、多次输⼊1.1 输⼊格式1.2 举例说明5、数组1.1 数组输⼊格式:2.1 数组转换成字符串6、字符串1.1 字符串转换成整型,浮点型(以整型为例)1.2 整型,浮点型转换成字符串2.1 字符串转换成字符数组2.2 字符数组转换成字符串3 举例说明7、写在最后C语⾔学习完转到Java后,第⼀个感觉就是Java的写法很复杂,同时,在常⽤的数据类型的输⼊输出上也没有C语⾔那么⽅便。
在C语⾔上⾯,⽤ scanf 函数可以很⽅便的输⼊⼤多数格式,在Java上却不⾏,Java当中没有类似于scanf的语句。
本⽂搭配本⼈的输⼊输出习惯及做题的记录,对这些不同类型的如整型的,是整型的但隔开参数的...做⼀个总结。
下⾯的说明中主类均为Main类,我们使⽤Scanner来进⾏输⼊。
每⼀种输⼊或输出可能有多种⽅法,本⼈只写了较为简单的写法。
1、Char型这⾥说的char型指的是只输⼊⼀个字符的情况。
1.1 输⼊格式:import java.io.IOException;//导⼊包public class Main {public static void main(String[] args) throws IOException {char ch = (char)System.in.read();//<1>System.out.println((int)ch);}}说明:需要搭配IOException异常来使⽤。
<1>中,System.in就是从标准输⼊流(最常见的是键盘)输⼊,rand()⽅法是从这个流⾥⾯读取输⼊的内容。
Java基础输入输出总结
![Java基础输入输出总结](https://img.taocdn.com/s3/m/2d798e1967ec102de2bd8957.png)
4.关闭相关流对象
osw.flush();
osw.close();
使用DataInputStream读取二进制文件
1.引入相关类
import java.io.*;
2.构造一个数据输入流对象
FileInputStream fis = new FileInputStream(path);
使用FileInputStream读取文件步骤:
1.引入相关类
import java.io.*;
2.创建一个文件输入流对象
InputStream is = new FileInputStream(path);
3.利用文件输入流的方法读取文本文件的数据
is.available(); 可读取的字节数
ObjectOutputStream oos = new ObjectOutputStream(fos);
3.调用writeObject()方法将对象写入文件
oos.writeObject(对象);
4.关闭对象输出流
oos.close();
反序列化步骤
1.
BufferWriter bw = new BufferWriter(fw);
3.利用BufferWriter类的方法写文本文件
bw.write(“hello”);
4.相关流对象的清空和关闭
bw.flush();
bw.close();
使用InputStreamReader读文件
File类常用方法
boolean exists( ) 判断文件或目录是否存在
boolean isFile( ) 判断是否是文件
java基本输入输出入门
![java基本输入输出入门](https://img.taocdn.com/s3/m/fe20c89c1b37f111f18583d049649b6648d70923.png)
java基本输入输出入门Java基本输入输出入门一、Java基本开发环境1.JDK1.5以上编译运行环境2.Ecllipse3.2以上开发环境二、Java之输入输出处理由于ACM竞赛题目的输入数据和输出数据一般有多组(不定),并且格式多种多样,所以,如何处理题目的输入输出是对大家的一项最基本的要求。
这也是困扰初学者的一大问题。
1.输入:格式1:Scanner sc=new Scanner(new BufferedInputStream(System.in));格式2:Scanner sc=new Scanner(System.in);在读入数据量大的情况下,格式1的速度会快些。
读一个整数:int n=sc.nextInt();相当于scanf("%d",&n);或cin>>n;读一个字符串:String s=sc.next();相当于scanf("%s",s);或cin>>s;读一个浮点数:double t=sc.nextDouble();相当于scanf("%lf",&t);或cin>>t;读一整行:String s=sc.nextLine();相当于gets(s);或cin.getline(...);判断是否有下一个输入可以用sc.hasNext()或sc.hasNextInt()或sc.hasNextDouble()或sc.hasNextLine()例1:读入整数Input输入数据有多组,每组占一行,由一个整数组成。
Sample Input56100123import java.util.Scanner;public class Main{public static void main(String[]args){Scanner sc=new Scanner(System.in);while(sc.hasNext()){//判断是否结束int score=sc.nextInt();//读入整数。
Java输入输出流详解
![Java输入输出流详解](https://img.taocdn.com/s3/m/de10c4b0aeaad1f347933f24.png)
通过数据流、序列化和文件系统提供系统输入和输出。
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文件流....本文的目的是为大家做一个简要的介绍。
流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。
java标准输入输出常用方法
![java标准输入输出常用方法](https://img.taocdn.com/s3/m/0baf61525e0e7cd184254b35eefdc8d377ee1452.png)
java标准输入输出常用方法Java标准输入输出是Java编程语言中常用的输入输出方式,它们提供了方便快捷的数据传输功能。
在Java中,标准输入输出包括标准输入流(stdin)、标准输出流(stdout)和标准错误输出流(stderr)。
这些流对象都是java.io包中的抽象类,它们提供了许多常用的方法来实现数据的输入输出操作。
一、标准输入流(stdin)标准输入流是一个常用的输入流对象,通常用于从控制台读取用户输入的数据。
Java提供了许多常用的方法来实现对标准输入流的读取操作。
以下是一些常用的方法:1.read()方法:用于从标准输入流中读取一个字节数据,并返回该数据的字节值。
如果读取成功,返回值为1;如果读取失败或到达文件末尾,返回值为-1。
示例代码:```javaintdata=stdin.read();```2.readLine()方法:用于从标准输入流中读取一行数据,并返回该行的字符串值。
该方法会一直读取直到遇到换行符或到达文件末尾。
示例代码:```javaStringline=stdin.readLine();```3.readInt()方法:用于从标准输入流中读取一个整数数据,并返回该数据的整数值。
该方法会读取一个整数数据,并将其存储在一个int类型的变量中。
示例代码:```javaintnum=stdin.readInt();```需要注意的是,在使用标准输入流时,需要注意控制台的缓冲区大小和读取速度,以免造成数据丢失或程序崩溃。
二、标准输出流(stdout)标准输出流是一个常用的输出流对象,通常用于将数据输出到控制台或文件。
Java提供了许多常用的方法来实现对标准输出流的输出操作。
以下是一些常用的方法:1.write()方法:用于将一个字节数据写入到标准输出流中。
该方法需要一个byte类型的参数,表示要写入的字节数据。
示例代码:```javastdout.write(data);```2.print()方法:用于将一个对象写入到标准输出流中,并自动将其转换为字符串形式进行输出。
Java输入输出流(一)——常用的输入输出流
![Java输入输出流(一)——常用的输入输出流](https://img.taocdn.com/s3/m/bc1aa36000f69e3143323968011ca300a6c3f67f.png)
Java输⼊输出流(⼀)——常⽤的输⼊输出流1.流的概念:在Java中,流是从源到⽬的地的字节的有序序列。
Java中有两种基本的流——输⼊流(InputStream)和输出流(OutputStream)。
根据流相对于程序的另⼀个端点的不同,分为节点流和过滤流。
(1)节点流:以特定源如磁盘⽂件、内存某区域或者线程之间的管道为端点的构造输⼊输出流,是⼀种基本的流。
(2)过滤流:以其他已经存在的流为端点构造的输⼊输出流。
根据流中的数据单位分为字节流和字符流。
(1)字节流:流中的数据是以8位字节为单位进⾏读写,以InputStream和OutputStream为基础类。
(2)字符流:流中的数据是以16为字符为单位进⾏读写,以Reader和Writer为基础类。
2.字节流InputStream和OutputStream是字节流的两个顶层⽗类,提供了输⼊流类和输出流类的通⽤API。
2.1 输⼊字节流InputStream基本⽅法:(1)基本读⽅法;: int read() int read(byte[] b) int read(byte[] b,int off,int len)(2) 关闭流:void close()(3) 返回输⼊流中还有多少可读字节 int available()(4) 跳过指定字节 long skip(long n)(5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()2.2 输出字符流OutputStream基本⽅法:(1)基本写⽅法:void write(int c) void write(byte[] b) void write(byte[] b,int off,int len)(2) 关闭流:void close()(3)q强制输出:void flush()3.字符流:Reader和Writer是字符流的顶层⽗类,字符流能够处理Unicode字符集中的所有字符。
Java的输入输出
![Java的输入输出](https://img.taocdn.com/s3/m/cfbabe4de518964bcf847c5c.png)
Java I/O 關鍵詞(一)部分1.File:描述了文件本身的属性,无关流操作。
ifFile, isAbsolute(绝对路径否), delete, isDirectory, list(字符串形式列出目录内容),listFiles(以File对象数组形式返回文件列表),mkdir, mkdirs(创建目录以及此目录的所有父目录)。
FilenameFilter 接口:String list(FilenameFilter ff)2.InputStream和OutputStream,子节流基础,抛出IOException。
3.FileInputStream:从文件中读取字节。
FileInputStream可用路径或File对象构造,一旦对象建立,文件就被打开并用于读取。
4.FileOutputStream:写字节到文件的输出流。
创建一个FileOutputStream对象并不依赖已存在的文件,如果对象创建时文件不存在,构造函数会自动建立这个文件。
5.ByteArrayInputStream:使用字节数组作为输入。
对应的有ByteArrayOutputStream。
6.过滤的字节流:如缓冲、字符转化、原始数据转化等。
他们都基于FilterOutputStream和FilterInputStream。
比如缓冲字节流:BufferedInputStream(其中有mark和reset用来定位值得注意)、BufferedOutputStream和PushbackInputStream(回退:读取一个字节,然后把它返回到流中);PrintStream 提供了格式化的能力;RandomAccessFile 不是从InputStream和OutputStream派生的,而是实现了DataInput和DataOutput 接口,封装了一个随机存取的文件。
7.字符流:Reader、Writer8.FileReader和FileWriter:文件操作9.CharArrayReader和CharArrayReader:以字符数组为源/目标的流10.BufferedReader和BufferedWriter:缓冲读写11.PushBackReader,PrintWriter等。
Java输入输出详解零基础学Java
![Java输入输出详解零基础学Java](https://img.taocdn.com/s3/m/c1286b0966ec102de2bd960590c69ec3d5bbdbe1.png)
Java输入输出详解零基础学Java本篇主要介绍Java的输入与输出,当然,这里说的是控制台下的输入与输出,窗口程序的设计将会再后续篇章中有详细说明。
Java的输出很简单,调用System.out.println(即可打印输出你想要输出的内容。
我们之前也已经看到过。
调用println(方法时,会自动在后面加上换行符,如果不希望它加换行符的话,就要使用print(方法了,之后的打印输出会紧跟其后,而不是另起一行。
另外,还有一个很常用的方法,那就是printf(,学过C或者C++的话,对这个printf(应该很熟悉,没错,在Java里几乎是一模一样的。
可以用来格式化输出内容。
第一个参数代表格式,格式中会有一个或者多个转换符,后续参数代表替换内容,用于替换转换符。
说这么多也没用,直接上代码。
package pers.frank.test;import java.util.Date;public class Testpublic static void main(String[] args)/*** 输出字符串 ***/// %s表示输出字符串,也就是将后面的字符串替换模式中的%sSystem.out.printf("%s", new Integer(1212));// %n表示换行System.out.printf("%s%n", "end line");// 还可以支持多个参数System.out.printf("%s = %s%n", "Name", "Zhangsan");// %S将字符串以大写形式输出System.out.printf("%S = %s%n", "Name", "Zhangsan");// 支持多个参数时,可以在%s之间插入变量编号,1$表示第一个字符串,3$表示第3个字符串System.out.printf("%1$s = %3$s %2$s%n", "Name", "san", "Zhang");/*** 输出boolean类型 ***/System.out.printf("true = %b; false = ", true);System.out.printf("%b%n", false);/*** 输出整数类型***/Integer iObj = 342;// %d表示将整数格式化为10进制整数System.out.printf("%d; %d; %d%n", -500, 2343L, iObj);// %o表示将整数格式化为8进制整数System.out.printf("%o; %o; %o%n", -500, 2343L, iObj);// %x表示将整数格式化为16进制整数System.out.printf("%x; %x; %x%n", -500, 2343L, iObj);// %X表示将整数格式化为16进制整数,并且字母变成大写形式System.out.printf("%X; %X; %X%n", -500, 2343L, iObj);/*** 输出浮点类型***/Double dObj = 45.6d;// %e表示以科学技术法输出浮点数System.out.printf("%e; %e; %e%n", -756.403f, 7464.232641d, dObj); // %E表示以科学技术法输出浮点数,并且为大写形式System.out.printf("%E; %E; %E%n", -756.403f, 7464.232641d, dObj); // %f表示以十进制格式化输出浮点数System.out.printf("%f; %f; %f%n", -756.403f, 7464.232641d, dObj);// 还可以限制小数点后的位数System.out.printf("%.1f; %.3f; %f%n", -756.403f, 7464.232641d, dObj); /*** 输出日期类型***/// %t表示格式化日期时间类型,%T是时间日期的大写形式,在%t 之后用特定的字母表示不同的输出格式Date date = new Date(;long dataL = date.getTime(;// 格式化年月日// %t之后用y表示输出日期的年份(2位数的年,如99)// %t之后用m表示输出日期的月份,%t之后用d表示输出日期的日号System.out.printf("%1$ty-%1$tm-%1$td; %2$ty-%2$tm-%2$td%n", date, dataL);// %t之后用Y表示输出日期的年份(4位数的年)// %t之后用B表示输出日期的月份的完整名, %t之后用b表示输出日期的月份的简称System.out.printf("%1$tY-%1$tB-%1$td; %2$tY-%2$tb-%2$td%n", date, dataL);// 以下是常见的日期组合// %t之后用D表示以 "%tm/%td/%ty"格式化日期System.out.printf("%1$tD%n", date);//%t之后用F表示以"%tY-%tm-%td"格式化日期System.out.printf("%1$tF%n", date);/*** 输出时间类型***/// 输出时分秒// %t之后用H表示输出时间的时(24进制),%t之后用I表示输出时间的时(12进制)// %t之后用M表示输出时间的分,%t之后用S表示输出时间的秒 System.out.printf("%1$tH:%1$tM:%1$tS; %2$tI:%2$tM:%2$tS%n",date, dataL);// %t之后用L表示输出时间的秒中的毫秒System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", date);// %t之后p表示输出时间的上午或下午信息System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", date); // 以下是常见的时间组合// %t之后用R表示以"%tH:%tM"格式化时间System.out.printf("%1$tR%n", date);// %t之后用T表示以"%tH:%tM:%tS"格式化时间System.out.printf("%1$tT%n", date);// %t之后用r表示以"%tI:%tM:%tS %Tp"格式化时间System.out.printf("%1$tr%n", date);/*** 输出星期***/// %t之后用A表示得到星期几的全称System.out.printf("%1$tF %1$tA%n", date);// %t之后用a表示得到星期几的简称System.out.printf("%1$tF %1$ta%n", date);// 输出时间日期的完整信息System.out.printf("%1$tc%n", date);}}这里包括了大部分的输出格式,多码几次的话就会使用了。
java输入输出语句整理总结
![java输入输出语句整理总结](https://img.taocdn.com/s3/m/e0d4bcc05122aaea998fcc22bcd126fff7055dd1.png)
java输入输出语句整理总结java输入输出语句整理总结System.out.print ——标准输出流Java的流类,主要是:输入流类InputStream 输出流类OutputStream Java系统预先定义好3个流对象,静态属性System.out 标准输出设备:显示器System.in 标准输入设备:键盘System.err 标准错误设备:屏幕System.out PrintStream类对象,输出字节数据流System.in InputStream类对象,输入字节数据流System.errprintStream类对象,输出系统错误信息输入:命令行——Eclipase“运行设置”中的参数直接从键盘输入——Like C Language——专业术语:控制台窗口输入,即程序直接读取键盘输入的数据public class Root { //求解方程ax+b=0的根xpublic static void main(String args[]) {float a, b, x;a=Float.parseFloat (args[0]); //命令行输入第一个数b=Float.parseFloat (args[1]); //命令行输入第二个数x=-b/a; // 求根xSystem.out.println("x="+x);} }将命令行第i个输入转换为以下类型的数据:整型数 a=Integer.parseInt(args[i]);短整型 a=Short.parseShort(args[i]);单精度浮点: a=Float.parseFloat(args[i]);双精度浮点: a=Double.parseDouble(args[i]);a=Long.parseLong (args[i]);a=Byte.parseByte (args[i]);Java 控制台输入 System.in.read()import java.io.*;// 声明导入IO包需要处理异常throws IOException 要导入 java.io.*public class StandardIn1 {public static void main(String[] args) throws IOException{System.out.println(" 输入一个字符");//System.in.read(); //利用read()语句暂缓程序运行只过滤一个字符char cc;cc=(char)System.in.read(); //从键盘输入read 得到一个字符,是 int 型System.out.print( cc);int c=System.in.read(); //从键盘输入System.out.print( c);shortsc=(short)System.in.read();System.out.print(sc);} }Java 控制台输入import java.io.*;//import java.util.*;不用导入此包class abc {public static void main(String[] args) throws IOException//public static void main(String[] args){ BufferedReader keyin =new BufferedReader(newInputStreamReader(System.in));// 或 InputStreamReader iin=newInputStreamReader(System.in);//BufferedReader keyin =new BufferedReader(iin);String c;c=keyin.readLine(); // readLine 得到的是 String 型System.out.println(c);int cc=keyin.read(); //数值类型 //或字符类型 charcc=(char)keyin.read();System.out.println(cc);}}在程序顶部加上语句:import java.util.Scanner; 或import java.util.*; // Java 的工具包使用标准输入流定义一个Scanner 对象 Scanner in = newScanner(System.in);Scanner 对象 Scanner属于Java标准输入流 System.innext 和 nextLine 得到的'是 String类型next 输入的字符是一个单词,即空格结束nextLine:输入是一个语句,以回车结束import java.io.*;// 声明导入IO包下面的 throws IOException 没有,则不用导入 java.util.*包import java.util.*; // Java 的工具包public class StandardIn1 {public static void main(String[] args) throws IOException{ Scanner kin = new Scanner(System.in); //定义Scanner kin对象System.out.println("请问你的姓名?");String name1 = in.nextLine(); // 若输入是 This is 则值是 This is System.out.printf("哦,你是"+ name1);String name2 = kin.next();// 若输入是This is 则值是This System.out.printf("哦,你是"+ name2);}}//String name = kin.next();// 若要从name处得到数值型,则用int x=Integer.parseInt(name)// 即 int name = Integer.parseInt(kin.next());或者Scanner类用法很多,包括输入各种类型的数据Scanner 对象从控制台读取的是字符串如果已定义了Scanner in对象,需要读取数据,可使用“方法”(数值类型至少是 int ,否则要强行转换)“方法”有 nextInt nextDouble nextFloat (Short)in.nextShort() (Byte)in.nextByte()读取整型数 int n=in.nextInt();// 回车结束输入读取浮点数 float x=in.nextFloat(); // 回车结束输入读取双精度数 double y=in.nextDouble(); // 回车结束输入long n=in.nextLong();short a=(short)in.nextShort();byte a=(byte)in.nextByte();Java 控制台输入import java.io.*;class abc {public static void main(String[] args) throws IOException { BufferedReader keyin =new BufferedReader(newInputStreamReader(System.in));int[] a=new int[5];String cc;for (int i=0; i<a.length; i++){ cc=keyin.readLine();a[i]=Integer.parseInt(cc);}for (int i=0; i<a.length; i++)System.out.print(a[i]);} }从控制台读取5个数据,写入整型数组a中,程序代码为:import java.io.*;import java.util.*; //import java.util.Scanner;class abc {public static void main(String[] args) throws IOException//public static void main(String[] args){Scanner in = new Scanner(System.in);System.out.println("请输入");// System.in.read(); //利用read()语句暂缓程序运行int [] a= new int[5];for(int i=0; i<5;i++)a[i]=in.nextInt();for(int i=0; i<5;i++)System.out.print(a[i]); //输出}}在Java中,提供对话框输入程序顶部加入语句 import javax.swing.*;在程序中使用:JOptionPane.showInputDialog例如: String in_x = JOptionPane.showInputDialog("请输入:");使用对话框输入的也是字符,如果需要转换为其他类型的数据,使用Java方法 Integer.ParseIntDouble.PasreDouble ...注意:使用对话框,必须程序最后一条语句应该为System.exit(0);因为每打开一个对话框,相当于启动一个线程System.exit()是结束线程的语句import javax.swing.*;class abc {public static void main(String[] args){ String in_x = JOptionPane.showInputDialog("请输入:"); // System.out.printf("%d",(long)Integer.parseInt(in_x));System.out.print((long)Integer.parseInt(in_x));System.exit(0);} }java 弹出对话框的简单方法import javax.swing.JOptionPane;public class MessageBox{public static void main(String args[]){JOptionPane.showMessageDialog( null,"sample dialog !");}}【java输入输出语句整理总结】。
Java中的输入输出流操作详解
![Java中的输入输出流操作详解](https://img.taocdn.com/s3/m/fdd918eb48649b6648d7c1c708a1284ac85005c6.png)
Java中的输入输出流操作详解Java是一种面向对象的编程语言,广泛应用于各种领域。
在Java中,输入输出流是非常重要的概念,它提供了一种机制来实现程序与外部世界的交互。
本文将详细介绍Java中的输入输出流操作,包括输入流和输出流的概念、常用的输入输出流类以及它们的用法。
一、输入流和输出流的概念在Java中,输入流和输出流是用于在程序与外部环境之间传输数据的通道。
输入流用于从外部环境(如文件、网络等)读取数据到程序中,而输出流则用于将程序中的数据写入到外部环境中。
输入流和输出流是Java IO库中的核心概念,通过它们可以实现数据的读取和写入。
二、常用的输入流类1. InputStreamInputStream是所有输入流类的抽象基类,它定义了读取字节的基本方法。
常用的InputStream的子类包括FileInputStream、ByteArrayInputStream和DataInputStream等。
FileInputStream用于从文件中读取数据,ByteArrayInputStream 用于从字节数组中读取数据,DataInputStream用于从输入流中读取基本数据类型。
2. ReaderReader是所有字符输入流类的抽象基类,它定义了读取字符的基本方法。
常用的Reader的子类包括FileReader和BufferedReader等。
FileReader用于从文件中读取字符,BufferedReader用于从字符输入流中读取字符并缓冲输入。
三、常用的输出流类1. OutputStreamOutputStream是所有输出流类的抽象基类,它定义了写入字节的基本方法。
常用的OutputStream的子类包括FileOutputStream、ByteArrayOutputStream和DataOutputStream等。
FileOutputStream用于将数据写入文件,ByteArrayOutputStream用于将数据写入字节数组,DataOutputStream用于将基本数据类型写入输出流。
Java 输入输出流详解
![Java 输入输出流详解](https://img.taocdn.com/s3/m/60c98d325a8102d276a22fb5.png)
Java 输入输出流详解文章分类:Java编程最近一段时间,处于失业状态,正好有机会对未理解的知识进行整理,面试中这部分的知识很大可能也是会遇到的。
下面的内容一部分是从网上筛选的,经过自己的梳理后总结的。
Java IO 用的是…decorator模式‟来构建的。
要容易理解Java IO 应该从对称性和两个模式(装饰器模式和适配器模式)这两方面进行分析。
装饰器模式:在由InputStream、OutputStream、Reader和Writer 代表的等级结构内部,有一些流处理器可以对另外一些流处理器起到装饰作用,形成新的、具有改善了的功能的流处理器。
下面是Decorator模式的结构图:ponent就是装饰器模式中公共方法的类,在装饰器模式结构图的顶层。
2.ConcreateComponent是转换器模式中具体的被装饰的类,IO包中的媒体流就是此种对象。
3.Decorator装饰器模式中的核心对象,所有具体装饰器对象的父类,完成装饰器的部分职能。
在上面的例子中Decorator类和这里的对应。
该类可以只做一些简单的包裹被装饰的对象,也可以还包含对Component 中方法的实现……他有一个鲜明的特点:继承至Component,同时包含一个Component作为其成员变量。
装饰器模式动机中的动态地增加功能是在这里实现的。
4.ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰器对象,他们完成具体的装饰功能。
装饰功能的实现是通过调用被装饰对象对应的方法,加上装饰对象自身的方法。
这是装饰器模式动机中的添加额外功能的关键。
装饰器模式相关知识参考/blog/static/18765136200701232434996/适配器模式:将一个类的接口转换成客户希望的另外一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
比如ByteArrayInputStream 是一个适配器类,它继承了InputStream,而封装了一个byte数组,换句话说,它将以个byte数组的接口适配成InputStream流处理器的接口。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第八章 输入输出流
【课前思考】
1. 字节流和字符流的基类各是什么?
2. 什么是对象的串行化?对象串行化的作用是什么?
【学习目标】
本讲主要讲述了java语言中的输入/输出的处理,通过本讲的学习,同学们可以编写更为完善的java程序。
import java.io.*;
public class Write1
{
public static void main(String args[])
{
try
{
System.out.print("Input: ");
int count,n=512; e[n];
? String list( ); //列出当前目录下的文件
例 8.4 自动更新文件。
本例使用File类对象对指定文件进行自动更新的操作。程序如下:
import java.io.*;
import java.util.Date;
import java.text.SimpleDateFormat;
}
System.out.println();
for (int i=0;i<COUNT;I++) 按字符方式输出buffer
{
System.out.print((char) buffer[i]);
}
System.out.println("count = "+ count); //buffer实际长度
import java.io.*;
public class Input1
{
public static void main(String args[]) throws IOException
{
System.out.println("Input: ");
byte buffer[] = new byte[512]; //输入缓冲区
进行I/O操作时可能会产生I/O例外,属于非运行时例外,应该在程序中处理。如:型FileNotFoundException, EOFException, IOException
例 8.2 打开文件。
本例以FileInputStream的read(buffer)方法,每次从源程序文件OpenFile.java中读取512个字节,存储在缓冲区buffer中,再将以buffer中的值构造的字符串new String(buffer)显示在屏幕上。程序如下:
int count = System.in.read(buffer); //读取标准输入流
System.out.println("Output: ");
for (int i=0;i<COUNT;I++) 输出buffer元素值
{
System.out.print(" "+buffer[i]);
? ◇ DataInputStream、DataOutputStream
? ◇ BufferedInputStream、BufferedOutputStream
字符流:
从Reader和Writer派生出的一系列类,这类流以16位的Unicode码表示的字符为基本处理单位
? Reader、Writer
普通文件信息和工具
? long lastModified( );//得到文件最近一次修改的时间
? long length( ); //得到文件的长度,以字节为单位
? boolean delete( ); //删除当前文件
目录操作
? boolean mkdir( ); //根据当前对象生成一个由该对象指定的路径
? 对象串行化的概念。
【知 识 点】
? I/O 流概述
? 文件处理
? 过滤流
? 字符流的处理
? 对象的串行化
? 其它常用的流
【内 容】
第一节 数据流的基本概念
? 理解数据流
流一般分为输入流(Input Stream)和输出流(Output Stream)两类,但这种划分并不是绝对的。比如一个文件,当向其中写数据时,它就是一个输出流;当从其中读取数据时,它就是一个输入流。当然,键盘只是一个数人流,而屏幕则只是一个输出流。
? String getParent( ); //得到一个文件的上一级目录名
? String renameTo(File newName); //将当前文件名更名为给定文件的完整路径
文件属性测试
? boolean exists( ); //测试当前File对象所指示的文件是否存在
? ◇ BufferedReader、BufferedWriter
? ◇ StringReader、StringWriter
第二节 字节流初步
InputStream 和OutputStream
? read():从流中读入数据
? skip():跳过流中若干字节数
? ◇ FileInputStream、FileOutputStream
? ◇ PipedInputStream、PipedOutputStream
? ◇ ByteArrayInputStream、ByteArrayOutputStream
? ◇ FilterInputStream、FilterOutputStream
? boolean canWrite( );//测试当前文件是否可写
? boolean canRead( );//测试当前文件是否可读
? boolean isFile( ); //测试当前文件是否是文件(不是目录)
? boolean isDirectory( ); //测试当前文件是否是目录
? available():返回流中可用字节数
? mark():在流中标记一个位置
? reset():返回标记过得位置
? markSupport():是否支持标记和复位操作
? close():关闭流
? int read()
从输入流中读一个字节,形成一个0~255之间的整数返回(是一个抽象方法)。
import java.io.*;
public class OpenFile
{
public static void main(String args[]) throws IOException
{
try
{ //创建文件输入流对象
FileInputStream rf = new FileInputStream("OpenFile.java");
public File(String patent,String child)
文件名的处理
? String getName( ); //得到一个文件的名称(不包括路径)
? String getPath( ); //得到一个文件的路径名
? String getAbsolutePath( );//得到一个文件的绝对路径名
【学习指南】
仔细阅读本章各知识点的内容, 深刻理解 java 语言中输入/输出流的处理方法,掌握处理问题的方法,多练习,多上机。
【难 重 点】
? 遇到实际问题时,要根据需要正确使用各种输入/输出流,特别是对中文使用适当的字符输入流。
? 正确使用对象串行化的方法。
? 处理字符流时,其构造方法的参数是一个字节流。
System.out.println("Save to Write1.txt!");
}
catch (IOException ioe)
{
System.out.println(ioe);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
第三节 文件操作
public class UpdateFile
? int read(byte b[])
读多个字节到数组中。
? int read(byte b[], int off, int len)
? write(int b)
将一个整数输出到流中(只输出低位字节,抽象)
? write(byte b[])
将字节数组中的数据输出到流中
? write(byte b[], int off, int len)
将数组b中从off指定的位置开始,长度为len的数据输出到流中
? flush():刷空输出流,并将缓冲区中的数据强制送出
? close():关闭流
从输入流中读取长度为len的数据,写入数组b中从索引off开始的位置,并返回读取得字节数。
int n=512;
byte buffer[] = new byte[n];
while ((rf.read(buffer,0,n)!=-1) && (n>0)) //读取输入流
{
System.out.print(new String(buffer));
}
System.out.println();
rf.close(); //关闭输入流
}
catch (IOException ioe)
{
System.out.println(ioe);
}
catch (Exception e)
{
System.out.println(e);