Java控制台的输入输出
Java输入输出流
Java输⼊输出流1.基础概念流：⼀组有序的数据结构，将数据从⼀个地⽅带到另⼀个地⽅。
根据数据流向的不同，可以分为输⼊流和输出流。
Java程序通过流完成输⼊/输出，所有的输⼊/输出都以流的形式处理。
(数据流是Java进⾏I/O操作的对象)1. 按照流的⽅向主要分为输⼊流和输出流两⼤类。
2. 数据流按照数据单位的不同分为字节流和字符流。
3. 按照功能可以划分为节点流和处理流。
数据流处理流程数据流的处理只能按照数据序列的顺序来进⾏，即前⼀个数据处理完之后才可处理后⼀个数据。
数据流以输⼊流的形式被程序获取，再以输出流的形式输出到其他设备。
输⼊/输出流模式如下:Java流相关的类都封装在java.io包中，且每个数据流都是⼀个对象。
1-输⼊流所有输⼊流都是InputStream抽象类(字节输⼊流)和Reader抽象类(字符输⼊流)的⼦类。
InputStream类的层次结构及常⽤⽅法如下:2-输出流所有输出流类都是OutputStream抽象类(字节输出流)和Writer抽象类(字符输出流)的⼦类。
OutputStream类的层次结构及常⽤⽅法:注:从本质上来讲，写数据（即输出）的时候，字节也好，字符也好，本质上都是没有标识符的，需要去指定编码⽅式。
但读数据的时候，如果我们需要去“看数据”，那么字节流的数据需要指定字符编码⽅式，这样我们才能看到我们能识别的字符(否则乱码)；⽽字符流，因为已经选择好了字符编码⽅式，通常不需要再改了2.Java系统流Java程序运⾏时⾃带有⼀个系统流(对应类ng.System)。
该类封装了Java程序运⾏时的三个系统流(作⽤域为public和static):1. System.in:标准输⼊流，默认设备为键盘2. System.out:标准输出流，默认设备为控制台。
3. System.err:标准错误流，默认设备是控制台。
3.Java File(⽂件操作类)File类是Java.io包中唯⼀代表磁盘⽂件本⾝的对象(File类不能访问⽂件内容本⾝，需使⽤输⼊/输出流访问)File类的三种构造⽅法:1. File(String path):path可为⽬录/⽂件，File对象标识的就是⽬录/⽂件为⽂件时idea中默认路径为⼯程路径2. File(String path, String name):path是路径，name是⽂件名3. File(File dir, String name):dir是路径对象，name是⽂件名File类两个常⽤常量如下:1. public static final String pathSeparator:分隔连续多个路径字符串的分隔符(win下为;)2. public static final String separator:分隔同意路径字符串中的⽬录(win下为/)注:win中⽂件⽬录D:\xxx\xx,Java中使⽤时\应为/或\File类常⽤⽅法如下:通过遍历⽬录可以在指定的⽬录中查找⽂件或显⽰所有⽂件列表，有如下两种重载形式1. String[] list() 返回File对象表⽰⽬录中所有⽂件和⼦⽬录名称的字符串数组(null)eg.String path = "D:/IdeaProject/";File ff = new File(path);String[] FileList = ff.list();for(String str: FileList){System.out.println(str + (new File(path, str).isFile()? "⽂件": "⽂件夹"));System.out.println(str + "字节长度为" + (new File(path, str).length()));}2. String[] list(FilenameFilter filter) 返回数组中仅包含filter过滤器的⽂件和⽬录(null则接受所有名称)注:需先实现java.io.FilenameFilter接⼝，然后将过滤类传递给list⽅法(FileStream)@Override public boolean accept(File dir, String name) { return name.endsWith(".idea") || name.endsWith(".txt"); }也可在list中直接实现接⼝String[] filterList = ff.list(new FilenameFilter() { @Override public boolean accept(File dir, String name) { return name.endsWith(".idea") || name.endsWith(".txt"); } });eg.String[] filterList = ff.list(new FileStream());for(String str: filterList){System.out.println(str + (new File(path, str).isFile()? "⽂件": "⽂件夹"));System.out.println(str + "字节长度为" + (new File(path, str).length()));}4.Java动态读取⽂件内容⽂件的输⼊和输出主要通过Scanner类从⽂件中读取⽂本数据；PrintWriter类向⽂本写⼊数据PrintWriter output = new PrintWriter(file);Scanner input = new Scanner(file);使⽤try-with-resources⾃动关闭资源AutoCloseable⼦类型(Scanner,PrintWriter)资源有close⽅法，使⽤完的资源close以防⽌内存泄漏。
Java基础输入输出
Java基础输入输出io包支持Java的基本I/O（输入/输出）系统，包括文件的输入/输出。
对输入/输出的支持是来源于Java的内核API 库，而不是语言关键字。
一、输入/输出基础很多实际的Java应用程序不是基于文本的控制台程序。
尽管基于文本的程序作为教学实例是很出色的，它们无法胜任JA V A在实际中的重要应用。
Java对外设输入/输出的支持也是有限的，并且用起来有些笨拙——甚至是在简单的例子程序中。
基于文本的控制台输入/输出对于Java程序并不是十分重要。
Java 提供了与文件和网络相关的强大的和灵活的输入/输出支持，Java的输入/输出系统是紧密相连并且是具有一致性的。
1.1 流的概念Java程序通过流来完成输入/输出。
流是生产或消费信息的抽象。
流通过Java的输入/输出系统与物理设备链接。
尽管与它们链接的物理设备不尽相同，所有流的行为具有同样的方式。
这样，相同的输入/输出类和方法适用于所有类型的外部设备。
这意味着一个输入流能够抽象多种不同类型的输入：从磁盘文件，从键盘或从网络套接字。
同样，一个输出流可以输出到控制台，磁盘文件或相连的网络。
流是处理输入/输出的一个洁净的方法，例如它不需要代码理解键盘和网络的不同。
Java中流的实现是在java.io包定义的类层次结构内部的。
1.2 字节流和字符流要使用流类，必须导入Java.io包。
Java 2 定义了两种类型的流：字节类和字符类。
字节流（byte stream）为处理字节的输入和输出提供了方便的方法。
例如使用字节流读取或书写二进制数据。
字符流（character stream）为字符的输入和输出处理提供了方便。
它们采用了统一的编码标准，因而可以国际化。
在某些场合，字符流比字节流更有效。
在最底层，所有的输入/输出都是字节形式的。
基于字符的流只为处理字符提供方便有效的方法。
下面是对字节流和字符流的概述。
1.2.1 字节流类字节流由两个类层次结构定义。
java输入输出语句例子
java输入输出语句例子Java语言中的输入输出语句是开发者经常使用的重要命令之一。
在本文中，我们将通过几个例子来展示Java中如何使用输入输出语句。
1. 导入Java中的I/O库在使用Java中的输入输出语句之前，我们需要先导入Java中的I/O库。
通过这个库，我们可以轻松地从键盘读取输入、从文件中读取输入和将输出写入文件。
在Java中，我们通常使用java.io包中的类来处理输入输出任务。
为了导入这个包，我们只需要在Java程序的开头添加以下代码：```import java.io.*```2. 使用Java中的输入输出语句一旦我们导入了Java中的I/O库，我们就可以开始使用Java中的输入输出语句了。
以下是几个例子：- 读取键盘输入并将其打印出来```import java.io.*public class InputOutputExample{public static void main(String args[]) throws IOException{BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));System.out.println("Enter your name: ");String name = inp.readLine();System.out.println("Hi " + name + ", nice to meet you!"); }}```在这个例子中，我们创建了一个BufferedReader对象，并使用它来读取来自键盘的输入。
我们使用System.in作为我们的输入源，并使用InputStreamReader将它们从字节流转换为字符流。
最后，我们使用BufferedReader的readLine()方法来读取用户输入。
Java 流输入输出
Java 流(Stream)、文件(File)和IOJava.io包几乎包含了所有操作输入、输出需要的类。
所有这些流类代表了输入源和输出目标。
Java.io包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
一个流可以理解为一个数据的序列。
输入流表示从一个源读取数据，输出流表示向一个目标写数据。
Java为I/O提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。
但本节讲述最基本的和流与I/O相关的功能。
我们将通过一个个例子来学习这些功能。
读取控制台输入Java的控制台输入由System.in完成。
为了获得一个绑定到控制台的字符流，你可以把System.in包装在一个BufferedReader 对象中来创建一个字符流。
下面是创建BufferedReader的基本语法：BufferedReader br = new BufferedReader(newInputStreamReader(System.in));BufferedReader对象创建后，我们便可以使用read()方法从控制台读取一个字符，或者用readLine()方法读取一个字符串。
从控制台读取多字符输入从BufferedReader对象读取一个字符要使用read()方法，它的语法如下：int read( ) throws IOException每次调用read()方法，它从输入流读取一个字符并把该字符作为整数值返回。
当流结束的时候返回-1。
该方法抛出IOException。
下面的程序示范了用read()方法从控制台不断读取字符直到用户输入"q"。
// 使用BufferedReader 在控制台读取字符import java.io.*;public class BRRead {public static void main(String args[]) throws IOException{char c;// 使用System.in 创建BufferedReaderBufferedReader br = new BufferedReader(newInputStreamReader(System.in));System.out.println("Enter characters, 'q' to quit.");// 读取字符do {c = (char) br.read();System.out.println(c);} while(c != 'q');}}以上实例编译运行结果如下:Enter characters, 'q' to quit.123abcq123abcq从控制台读取字符串从标准输入读取一个字符串需要使用BufferedReader的readLine()方法。
第9讲 java的输入输出(一)
17
9.3.1 File类
2. File(String path, String filename) 参数：path:文件所在目录的路径名 filename:文件名
File aFile=new File(“d:/temp”, “cc.txt”)
18
9.3.1 File类
3. File(File dir, String filename) 参数：dir:目录文件对象 filename:文件名
Reader Class的继承关系：
9
9.2
Java用于输入输出流的类
Writer Class的继承关系：
10
预定义的标准流（字节流）
System.out是标准的输出流，默认情况 下，它是一个控制台。 System.in是标准输入流，默认情况下， 它连接的另一端指的是键盘。 System.err指的是标准错误流，它默认是 控制台。
3
9.1
2. 输出流
流概念
通过打开一个连接到目标的输出流，程序可以 向外部目标顺序写数据。
4
9.2
Java用于输入输出流的类
按所读写的数据类型分两类：
字节流类（Byte Streams） 字节流类用 于向字节流读写8位二进制的字节。 字符流类（Character Streams） 字符 流类用于向字符流读写16位二进制字符。
5
9.2
Java用于输入输出流的类
java.io中的基本流类：
说明：它们是抽象类，不能直接创建对象。
6
9.2
Java用于输入输出流的类
InputStream Class的继承关系：
7
9.2
Java用于输入输出流的类
JAVA的输入输出程序设计举例
JAVA的输入输出程序设计举例Java的输入输出（I/O）程序设计是指通过流（stream）来实现数据输入和输出的操作。
在Java中，主要通过字节流和字符流来进行输入输出操作。
以下是一些常见的Java输入输出的示例：1. 使用标准输入输出流（System.in和System.out）进行控制台输入输出：```javaimport java.util.Scanner;public class ConsoleIOExamplepublic static void main(String[] args)//从控制台读取输入Scanner scanner = new Scanner(System.in);System.out.print("请输入您的姓名：");String name = scanner.nextLine(;System.out.print("请输入您的年龄：");int age = scanner.nextInt(;//输出结果到控制台System.out.println("您的姓名是：" + name);System.out.println("您的年龄是：" + age);}```2.使用文件输入输出流进行文件的读写操作：```javaimport java.io.*;public class FileIOExamplepublic static void main(String[] args)try//写入文件FileWriter writer = new FileWriter("file.txt");writer.write("Hello, World!");writer.close(;//读取文件FileReader reader = new FileReader("file.txt"); BufferedReader bufferedReader = new BufferedReader(reader); String line;while ((line = bufferedReader.readLine() != null)System.out.println(line);}reader.close(;} catch (IOException e)e.printStackTrace(;}}```3.使用对象输入输出流进行对象的读写操作：```javaimport java.io.*;class Student implements Serializable private String name;private int age;public Student(String name, int age) = name;this.age = age;}public String getNamreturn name;}public int getAgreturn age;}public class ObjectIOExamplepublic static void main(String[] args)Student student = new Student("John", 20);try//写入对象到文件ObjectOutputStream objectOutputStream = new ObjectOutputStreamnew FileOutputStream("student.ser"));objectOutputStream.writeObject(student);objectOutputStream.close(;//从文件中读取对象ObjectInputStream objectInputStream = new ObjectInputStream new FileInputStream("student.ser"));Student restoredStudent = (Student)objectInputStream.readObject(;objectInputStream.close(;System.out.println("姓名：" + restoredStudent.getName();System.out.println("年龄：" + restoredStudent.getAge();} catch (IOException ， ClassNotFoundException e)e.printStackTrace(;}}```这些示例涵盖了Java输入输出的基本用法，包括控制台输入输出、文件的读写和对象的序列化与反序列化。
第八章java的输入输出-PPT精品.ppt
File tests:
String getName()
boolean exists()
String getPath()
boolean canWrite()
String getAbsolutePath() boolean canRead()
String getParent()
boolean renameTo( File newNbaomoel)ean isFile()
17
第八章 java的输入输出
8.3 数据流的使用
18
第八章 java的输入输出
8.3 数据流的使用
1.如何使用文件流： 例题：将一个文件的内容拷贝到另一个文件。 见：copy.java
19
第八章 java的输入输出
介绍 File 类
File类用来访问本地文件系统中的文件和目 录。
1. 创建File类
6
第八章 java的输入输出
8.2 Java用于输入输出流的类
按所读写的数据类型分两类：
字符流类（Character Streams） 字符流类用于 向字符流读写16位二进制字符。
字节流类（Byte Streams） 字节流类用于向字 节流读写8位二进制的字节。一般地，字节流类 主要用于读写诸如图象或声音等的二进制数据。
7
第八章 java的输入输出
8.2 Java用于输入输出流的类
java.io中的基本流类：
说明：它们是抽象类，不能直接创建对象。
8
第八章 java的输入输出
8.2 Java用于输入输出流的类
1. InputStream 方法
The three basic read methods:
java的数据输入：从控制台输入数据
11:byte[ ] data=new byte[1];12:BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 13:BufferedOutputStream bos = new BufferedOutputStream(newFileOutputStream(dstFile));14:while(bis.read(data) != -1) bos.write(data);15:bos.flush();16:System.out.println("文件复制成功！");17:bis.close();18:bos.close();19:}catch(IOException e){20: e.printStackTrace();21:}22:}23:}可见利用标准输入流进行控制台输入的方式非常麻烦：如果从键盘获取的是字符串，需要采用B u ffered Read e r类来进行处理；如果获取的是其他类型数据，需要手工进行转换；在读取的过程中还必须捕获IO E xcep t io n。
不过这是JDK1.4及更早版本中从控制台读取数据唯一办法。
7.8.2 使用Scanner类的方式从JDK5.0开始，ja va.u t il包中增加了S c a n ner类，它是一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
S can ne r类从字面上讲是“扫描”的意思，它把给定的字符串解析成Jav a的各种基本数据类型，用于分解字符串的默认的分隔符是空格，也可以定制。
其构造方法如表7-15。
表7-15S cann er类的构造方法方法描述Scanner(File source)Scanner(File source, String charsetName)构造一个新的Scanner，其值是从指定文件扫描获得。
java控制台输入输出
java控制台输⼊输出⼀、⽐较传统的输⼊⽅法⽤输⼊流，得到字符串后要另⾏判断、转换案例import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class MainRun {public static void main(String[] args) {try {BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输⼊⼀个整数：");String str1 = bufferedReader.readLine();Integer int1 = Integer.valueOf(str1);System.out.println("输⼊的整数是：" + int1);System.out.println("请输⼊⼀个浮点数：");String str2 = bufferedReader.readLine();Double double1 = Double.valueOf(str2);System.out.println("输⼊的浮点数是：" + double1);} catch (IOException e) {e.printStackTrace();}}}请输⼊⼀个整数：234输⼊的整数是：234请输⼊⼀个浮点数：23输⼊的浮点数是：23.0⼆、JDK5以后有了Scanner处理控制台输⼊格式1: Scanner sc = new Scanner(new BufferedInputStream(System.in));格式2: Scanner sc = new Scanner(System.in);在有多⾏数据输⼊的情况下，⼀般这样处理：while(sc.hasNextInt()){...} 或者while(sc.hasNext()){}读⼊⼀个字符串： String str = sc.next();读⼊⼀整⾏数据： String lineString=sc.nextLine();读⼊⼀个布尔值：boolean boolenaNumber = sc.nextBoolean();读⼊⼀个字节型数据：byte byteNumbe = sc.nextByte();读⼊⼀个短整型数据：short shortNumber=sc.nextShort();读⼊⼀个整数：int intNumber = sc.nextInt();读⼊⼀个长整型数据：long longNumber=sc.nextLong();读⼊⼀个单精度浮点数：float floatNumber=sc.nextFloat();读⼊⼀个双精度浮点数：double doubleNumber=sc.nextDouble();对于计算代码运⾏时间：long startTime = System.nanoTime();// … the code being measured …long estimatedTime = System.nanoTime() - startTime;输⼊案例：输⼊数据有多组，每组占2⾏，第⼀⾏为⼀个整数N,指⽰第⼆⾏包含N个实数Scanner sc = new Scanner(System.in);while(sc.hasNext()){int n = sc.nextInt();for(int i=0;i<n;i++){double a=sc.nextDouble();...}三、输出：输出内容：System.out.print("");输出内容并换⾏：System.out.println("");格式化输出： System.out.format(String format, Object ... args);等价于 System.out.printf((String format, Object ... args);各种格式化样式说明：格式化输出案例：// System.out.printf(format, args);format为指定的输出格式，args参数System.out.printf("%+8.3f\n", 3.14); // "+"表⽰后⾯输出的数字会有正负号，正的+,负的-// ;8.3f表⽰输出浮点数，宽度为8，⼩数点保持3位有效System.out.printf("%+-8.3f\n", 3.14);// "-"表⽰靠左对齐System.out.printf("%08.3f\n", 3.14);// "0"8位宽度中⾃动补0System.out.printf("%(8.3f\n", -3.14);// "("如果是负数，⾃动加上( )System.out.printf("%,f\n", 123456.78); // ","⾦钱表⽰⽅法，每三位有⼀个逗号System.out.printf("%x\n", 0x2a3b); // 输出16进制数System.out.printf("%#x\n", 0x2a3b);// 输出带0x标识的16进制数System.out.printf("⽼板：您名字%s,年龄：%3d岁,⼯资：%,-7.2f\n", "ajioy", 21,36000.00);System.out.printf("⽼板：您名字%1$s,年龄：%2$#x岁\n", "ajioy", 38); // "n{1}quot;表⽰⽤第n个参数输出结果：+3.140+3.1400003.140(3.140)123,456.7800002a3b0x2a3b⽼板：您名字ajioy,年龄： 21岁,⼯资：36,000.00⽼板：您名字ajioy,年龄：0x26岁五、规格化输出SimpleDateFormat：SimpleSimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM⽉dd⽇ HH时mm分ss秒 E ");System.out.println(myFmt.format(new Date()));输出结果：2016年09⽉08⽇ 17时34分01秒星期四DecimalFormat：DecimalFormat 是 NumberFormat 的⼀个具体⼦类，⽤于格式化⼗进制数字。
第9章 Java输入输出
第9章Java输入/输出输入/输出处理是程序设计中的重要部分，例如从键盘读取数据、从文件中读取数据或向文件中写数据等。
Java语言把这些不同类型的输入、输出源抽象为流(Stream)，用统一接口来表示，从而使程序简单明了。
9.1 输入/输出基础Java语言的输入/输出功能必须使用类库java.io来实现，这个类库中的大部分是用来完成流式输入/输出的类。
9.1.1 流的概念在Java语言中程序所完成的输入和输出操作是以流的形式来实现的。
所谓流，是指在计算机的输入与输出之间运动的数据序列。
流序列中的数据既可以是未加工的原始的二进制数据，也可以是经过一定编码处理后符合某种格式规定的特定数据。
通常，Java程序的输入/输出操作主要针对三种不同的类型：(1)控制台，指的是屏幕输出(在Windows 系统下指的是DOS窗口)和键盘输入；(2)文件，针对磁盘文件的读/写操作；(3)网络，通过网络套接字所实现的数据访问。
基于上述流的概念，通过Java程序实现输入/输入操作必须遵循下列流程，该流程适用于上述所提到的文件和网络输入/输出类型。
这里将输入操作定义为“读”，读操作针对的流为输入流；将输出操作定义为“写”，写操作针对的流为输出流。
(1) “读”流程open an input stream //打开一个输入流while more information //判断该流中是否存有数据read information //如果有数据，则读入程序close the input stream //输入流中数据读完，关闭该输入流(2) “写”流程open an output stream //打开一个输出流while more information //判断程序中是否有数据要写到该输出流中write information //如果有数据，则写入close the output stream //数据写完，关闭该输出流输入流只能从中读取数据，而不能向其写出数据；输出流只能向其写出数据，而不能从中读取数据。
java 输入窗口和输出窗口写法
一、背景介绍1. Java是一种面向对象的编程语言，广泛应用于企业级应用开发和互联网应用开发领域。
2. 在Java编程中，输入窗口和输出窗口是常用的交互界面，用于接收用户输入和显示程序运行结果。
3. 本文将介绍Java中输入窗口和输出窗口的写法，以及常见的应用场景。
二、输入窗口的写法1. 使用Scanner类来实现输入窗口。
Scanner scanner = new Scanner(System.in);String input = scanner.nextLine();// 读取用户输入并存储到变量input中2. 使用JOptionPane类来实现图形化输入窗口。
String input = JOptionPane.showInputDialog("请输入内容：");// 弹出带有输入框的窗口，等待用户输入，并将用户输入的内容存储到变量input中三、输出窗口的写法1. 使用System.out.println()来实现控制台输出。
System.out.println("Hello, World!");// 在控制台输出字符串"Hello, World!"2. 使用JOptionPane类来实现图形化输出窗口。
JOptionPane.showMessageDialog(null, "Hello, World!"); // 弹出带有消息提示框的窗口，显示字符串"Hello, World!"四、输入窗口和输出窗口的应用场景1. 输入窗口的应用- 用户信息输入：例如登录界面、注册界面等需要用户输入信息的场景。
- 数据采集：例如统计调查、问卷调查等需要用户提供信息的场景。
2. 输出窗口的应用- 程序执行结果展示：用户操作的反馈信息、程序执行的结果展示等应用场景。
- 提示信息显示：警告、错误提示、成功提示等信息的显示。
java输入输出实验报告
java输入输出实验报告Java输入输出实验报告引言：Java是一种广泛应用的编程语言，其输入输出（Input/Output，简称I/O）功能对于程序的交互和数据处理至关重要。
本实验旨在通过实际操作，探索Java中的输入输出机制，并深入了解其原理和应用。
一、实验目的通过本次实验，我们的目标是：1. 理解Java中的输入输出概念和基本原理；2. 掌握Java中的标准输入输出流（System.in和System.out）的使用；3. 学会使用Java中的文件输入输出流，实现对文件的读写操作；4. 熟悉Java中的异常处理机制，处理输入输出过程中的异常情况。
二、实验环境本次实验所需的环境和工具如下：1. Java开发工具（如Eclipse、IntelliJ IDEA等）；2. 一台配置良好的计算机。
三、实验过程1. 标准输入输出流的使用在Java中，标准输入流（System.in）用于接收用户的输入，标准输出流（System.out）用于向屏幕输出信息。
我们可以通过Scanner类来实现对标准输入流的读取，通过System.out.println()方法实现对标准输出流的输出。
下面是一个示例代码：```javaimport java.util.Scanner;public class StandardIOExample {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入您的姓名：");String name = scanner.nextLine();System.out.println("您好，" + name + "！欢迎使用Java输入输出功能。
"); }}```2. 文件输入输出流的使用除了标准输入输出流，Java还提供了FileInputStream和FileOutputStream类，用于实现对文件的读写操作。
实验四Java输入、输出和异常处理
实验四Java输入、输出和异常处理实验四Java输入、输出和异常处理一、实验目的1.了解I/O流的使用；2.掌握常见的输入/输出流类及其主要方法。
3.熟悉S y s t e m类，掌握标准输入/输出。
4.学会利用Try-catch-finally语句来捕获和处理异常；5.掌握自定义异常类的方法。
二、实验要求1.使用标准数据流的应用程序。
2.使用文件输入输出流的应用程序。
3.通过编程理解系统异常处理的机制和创建自定义异常的方法。
三、实验内容（一）使用标准数据流的应用程序标准数据流指在字符方式下（如D O S提示符）程序与系统进行输入输出的方式，键盘和显示器屏幕是标准输入输出设备，数据输入的起点为键盘，数据输出的终点是屏幕，输出的数据可以在屏幕上显示出来。
1．程序功能：将键盘上输入的字符在屏幕上显示出来。
2．编写S Y4_1.j a v a程序文件，源代码如下：c l a s s S Y4_1{p u b l i c s t a t i c v o i d m a i n(S t r i n g[]a rg s)t h r o w s j a v a.i o.I O E x c e p t i o n {b y t e b u ff e r[]=n e w b y t e[10];S y s t e m.o u t.p r i n t l n("从键盘输入不超过10个字符，按回车键结束输入：");i n t c o u n t=S y s t e m.i n.r e a d(b u f f e r);//读取输入的字符并存放在缓冲区b u ff e r中S y s t e m.o u t.p r i n t l n("保存在缓冲区b u ff e r中元素的个数为："+c o u n t);S y s t e m.o u t.p r i n t l n("b u f f e r中各元素的值为：");f o r(i n t i=0;i<="" u="">S y s t e m.o u t.p r i n t(""+b u ff e r[i]);//在屏幕上显示b u ff e r 元素的值}S y s t e m.o u t.p r i n t l n();S y s t e m.o u t.p r i n t l n("输出b u ff e r字符元素：");S y s t e m.o u t.w r i t e(b u ff e r,0,b u f f e r.l e n g t h);}}3．编译、运行S Y4_1.j a v a文件。
Java命令行输入输出
概念 3 从控制台输入：System.in（标准输入流）中的Scanner类可实现 从控制台输入数据。 首先定义一个Scanner类对象。例如： Scanner input=new Scanner(System.in); 然后调用Scanner类对象的下列方法来输入数据： next()：输入字符串，字符串以空格结束。 nextLine()：输入一行作为字符串，可以包含空格。 nextInt()：输入整数。 nextDouble()：输入浮点数。
Java命令行输入输出
密码输入 8 控制台对象的readPassword方法在输入数据时，不在显示器上显示 输入的数据。例如： char[] str3=con.readPassword("请输密码："); readPassword方法返回一个char数组。与readerLine方法类似， readPassword方法可以指定一个格式化的字符串作参数。例如： char[] str3=con.readLine("请输入用户%s的密码：","汤姆");
Java命令行输入输出
读一行数据 7 例如： String str2=con.readLine("请输入一个字符串："); 还可以为readerLine方法指定一个格式化的字符串，与printf方 法参数类似。 例如： String str2=con.readLine("请输入%s的姓名：","汤姆");
Java命令行输入输出
Java命令行输入输出
概念
4
Console（控制台）对象即可代表键盘，又可代表显示器，即可以完成 命令行的输入和输出。
System对象的console方法用于获得一个控制台对象实例。 例如：
Java输入输出详解零基础学Java
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 输入输出机制
1，操作文件或目录的属性数据流Java中把一组由序的数据序列称为流，根据操作的类型，可以把流分成输入流和输出流。
程序从输入流读取数据，从输出流写入数据。
Java.io包包含一组流类它对各种常见的输入流和输出流进行了抽象。
用来访问文件的java.io.File类文件的定义：相关记录或放在一起的数据的集合。
Java的File类提供定位本地文件系统，描述文件和目录的一个功能。
File类对象即可表示文件，也可以表示一个目录。
File 类构造方法：第一种构造方法：只有一个参数，它用来指定受操作的文件名，创建一个指向该文件的文件对象。
File（String pathname）例如：File fl = new File (“c:\\hello.txt”)；这个就是指向c盘的根目录下hello.txt文本文件的对象。
注意：在windows操作系统当中我们的分隔符采用的是反斜杠，在其他的操作系统如Linux操作体统这个文件的分隔符应该就用斜杠。
在这里用两个斜杠的意思就是其中有一个表示转换符。
这里为了不出现斜杠的问题，最保险的办法是使用File.Separator静态成员。
第二种构造方法：它有两个参数，其中第一个参数用来指定目录路径，第二个参数用来指定文件名。
File（String dir，String subpath）例如：File f2 = new File(“c:\\myDoc”,”temp.txt”);第三个构造方法：跟第二种构造方法的使用基本一致，第一个参数指定根目录，第二个参数设置子目录或文件。
File（File parent，String subpath）这个File对象是java.io包当中引用磁盘文件的唯一对象。
File类仅仅用来描述File对象的属性，它并不说明数据时如何存储的。
File类常用的方法：File类查看文件属性：判断文件的可读写性：输出结果：File类创建或删除文件和目录的方法创建文件方法：以上这段代码表示如果文件不存在则创建一个空文件删除文件方法：以上这段代码表示如果文件存在则删除文件下面是调用创建文件方法和删除文件方法的示例：fm是类对象，f1和f2是文件对象。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
如%8.4d, %8#d, %.d, %.4d. %8.d 等都是错误的,报非法格式转换。
x 及 o 格式: x 以无符号十六进制形式输出整数,o 以无符号八进制形式输出整数,先略举几种用法:
例子
printf(Integer.toBinaryString(-1)+" %#o %#x",-1,-1)//分别输出二进制、八进制、十六进制：
2.0 printf 输出格式化 [目录] Java 在控制台上打印输出一般不会有格式化的要求。例如我们可以使用 System.out.print(x) 将数值 x 输出到控制台上。这条命令将
以 x 对应的数据类型所允许的最大非 0 数字位数打印输出 x。
double x = 10000.0/3.0;
格式转换符将指示被格式化的数值类型。将这句"文言文"换成"白话文"的意思就是：格式转换符所起的作用就是为了说明数值格式化后的输 出类型是什么类型的。
表 3-5 列出了所有转换符:
转换符 d
类型 十进制整数
举例(输出) 159
转换符 s
类型 字符串
举例(输出) Hello
x
十六进制整数
9f 或 0x9f
}catch(FileNotFoundException e){ System.out.println(e);
} } private static void parseline(String line){
Scanner lineScanner = new Scanner(line);
eDelimiter(","); String name = lineScanner.next(); int age = lineScanner.nextInt(); String idate = lineScanner.next(); boolean iscertified = lineScanner.nextBoolean(); System.out.println("姓名:"+name+",年龄:"+age+",入司时间:"+idate+",验证标记:"+iscertified); } } 输出: 姓名:老赵,年龄:28,入司时间:feb-01,验证标记:true 姓名:小竹,年龄:22,入司时间:dec-03,验证标记:false 姓名:阿波,年龄:21,入司时间:dec-03,验证标记:false 姓名:凯子,年龄:25,入司时间:dec-03,验证标记:true
Scanner useDelimiter(Pattern pattern); //将扫描器的分隔模式设置为指定模式 Scanner useDelimiter(String pattern); //将此扫描器的分隔模式设置为从指定 String 构造的模式。 注意:其中 useDelimiter(String pattern)中的参数 pattern 是一个正规表达式。 下面看实例: Scanner in = new Scanner(System.in,"UTF-8"); eDelimiter("\""); System.out.println("what is your name?"); String firstname = in.next();//读取输入的下一个单词（以空格作为分隔符） System.out.println("Your firstName is "+ firstname); 输出： what is your name? Jan mi ba"can ken; Your firstName is Jan mi ba 上例以双引号作为单词分隔符修改默认以空格为分隔符的做法在现实中非常实用。 最后一个例子,读取并分析文本文件：D:\test.txt,文本文件的内容如下: 老赵,28,feb-01,true 小竹,22,dec-03,false 阿波,21,dec-03,false 凯子,25,dec-03,true 程序: import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.util.Scanner; public class ReadFile {
c
o
八进制整数
0237 或 237
b
f
定点浮点数
19.5
h
字符 布尔 散列码
H true 42628b2
e
指数浮点数
1.59e+01
tx
日期时间
(x 为表 3-7 的字符)
g
通用浮点数
--
%
百分号
%
a
十六进制浮点数
0x1.fccdp3
n
与平台有关的行分隔符
--
注:1.0 在 window 下行分隔符为"\r\n",在 linux 下行分隔符为"\n"。
输出及说明 11111111111111111111111111111111 037777777777 0xffffffff
例子
printf(Integer.toBinaryString(8<<2+1)+" %#o %#x",8<<2+1,8<<2+1)//分别输出：
宽度 m: m 指域宽,即对应的输出项在输出设备上所占的字符数。 精度 n: n 用于说明输出的实型数的小数位数。未指定精度 n 时，隐含的精度为 n=6 位。
d 格式: 用来输出十进制整数。d
按整型数据的实际长度输出
%md
m 为指定的输出字段的宽度。如果数据的位数小于 m，则左端补以空格，若大于 m，则按实际位数输出
public static void main(String[] args) { if(args.length != 1){ System.err.println("Usage:java readFile file location"); System.exit(0); } readFile(args[0]);
0
转换符为数值时,(不包括符号位)前面补 0(我称呼为 0 补位符)
-
左对齐(不能与 0 同时出现)
(
如数值为负数,则将负数取绝对值用括号括起来;正数不变
,
添加分组分隔符(千分位符)
#(f 格式)
包含小数点
#(x 或 o 格式)
添加前缀 0x 或 0
$
指定将被格式化的参数索引,例如%1$d,%1$x 将以十进制和十六进制格式打印第一个参数
<
格式化前面替换的数值,例如%d%<x 将以十进制和十六进制格式打印同一个参数
图 3-6 给出了格式说明符的语法图。
提示：参数索引值从 1 开始，而不是从 0 开始，%1$...对第 1 个参数格式化。这就避免了与 0 标志混淆。标志是闭回笼所以可以有多个标
志。参数索引和符号$在同一个回笼中所以两者必须同时出现或不出现,符号.和精度也是。 现在大致的对上面的语法图及各种转换符、标志做一个解析:
Java 控制台的输入输出
文档编辑：古寒笑 日期:2010-11-18
1.0 Scanner 对象操作 2.0 printf 输出格式化
目录
1.0 Scanner 对象操作 [目录] 在 JDK5.0 以后, 通过控制台进行输入有了更简单的方法。 首先我们需要构造一个 Scanner 对象,它附属于"标准输入流"System.in。 Scanner in = new Scanner(System.in); 常用构造方法: Scanner(File source): 构造一个新的 Scanner，它生成的值是从指定文件扫描的。 Scanner(InputStream source): 构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。 Scanner(String source): 构造一个新的 Scanner，它生成的值是从指定字符串扫描的。 现在,就可以使用 Scanner 类的各种方法实现输入操作了。例如,nextLine 方法将输入一行: Scanner in = new Scanner(System.in,"UTF-8"); System.out.println("what is your name?"); String name = in.nextLine();//读取输入的下一行内容 System.out.println("Your name is "+name); 输出： what is your name? Jan mi Your name is Jan mi 在这里,使用 nextLine 方法是因为在输入行中有可能包含空格。要想读取一个单词（默认是以空白符作为分隔符）,就调用 Scanner in = new Scanner(System.in,"UTF-8"); System.out.println("what is your name?"); String firstname = in.next();//读取输入的下一个单词（以空格作为分隔符） System.out.println("Your firstName is "+ firstname); 输出： what is your name? Jan mi Your firstName is Jan 要想读取并转换下一个表示整数或浮点数的字符序列,就调用 int nextInt( ) double nextDouble( ) 注意:上述方法执行时都会造成堵塞,等待用户在命令行输入数据回车确认。 要想检测输入中是否还有其他单词,就调用 boolean hasNext( ) 要想检测是否还有表示整数或浮点数的下一个字符序列,就调用 boolean hasNextInt( ) boolean hasNextDouble( ) 要想修改默认以空格作为分割符来区分不同的单词,就可以使用