第十二章输入输出流、文件及数据库
任何一个程序都有一个目的，即输入(提供)什么数据(信息)可输出(获得)所期望的结果。到目前为止，我们在程序中所讨论的输入和输出操作都是在标准设备文件上进行的。本章将简要介绍对数据流、数据文件和数据库文件的输入和输出操作。
12.1 输入输出流
输入输出是程序设计的重要组成部分，任何程序设计语言都提供对输入输出的支持。Java也不例外，它采用数据流的形式传送数据。
12.1.1 流的概念
所谓流（Stream），简单地说，即是计算机中数据的流动。
程序运行需要取得数据，这些数据可以通过用户从键盘输入获得，也可以从磁盘文件调入，还可以接收来自网络上的数据信息，程序在获得数据之后对其进行处理，并将处理结果输出到屏幕、磁盘文件或打印机上，也可输送到网络上（如远程打印机、网络用户等）。
对程序而言，数据信息从某个地方流向程序中，这就是输入流；数据信息从程序中发送到某个目的地，这就是输出流。
无论是输入流还是输出流，Java提供了如下两种方式进行处理：
1）字节（byte）方式
以字节方式处理的是二进制数据流（简称为字节流）。
用二进制的格式可以表示许多类型的数据，比如数字数据、可执行程序代码、因特网通信和类文件代码等等。
2）字符(character)方式
以字符方式处理的数据流称为字符流。它不同于字节流，因为Java使用Unicode字符集，存放一个字符需要两个字节。因此这是一种特殊类型的字节流，它只处理文本化的数据。所有涉及文本数据处理，诸如文本文件、网页以及其它常见的文本类型都应该使用字符流。
下边我们将分别介绍字节流和字符流的功能及应用。
12.1.2 字节流
在输入和输出流中用到了许多类，它们形成了一种非常合理的结构，只要我们了解了它们之间的相互关系，就可以正确地使用了。
1
下边我们先介绍字节输入流类的功能及应用。
1. 字节输入流类（InputStream）
InputStream类是一个抽象类，它是字节输入流的顶层类。我们不能直接创建InputStream 对象，要进行字节输入流的操作，还要靠创建它的子类对象实现。InputStream类被放在java.io 包中，它的派生结构如下：
class java.io.InputStream
|-class java.io.ByteArrayInputStream
|-class java.io.FileInputStream
|-class java.io.FilterInputStream
|-class java.io.BufferedInputStream
|-class java.io.DataInputStream
|-class java.io.LineNumberInputStream
|-class java.io.PushbackInputStream
|-class java.io.ObjectInputStream
|-class java.io.PipedInputStream
|-class java.io.SequenceInputStream
|-class java.io.StringBufferInputStream
InputStream类中提供了一系列的方法用来完成从字节输入流读取数据的操作，下边简要介绍一些常用的方法及其应用。
1）InputStream类的常用方法
abstract int read() 从输入流中读取一个字节并返回整数值（0～255）。如果流中无字节可读，则返回-1。该方法是一个抽象方法，在其子类中实现它。
int read(byte[] b) 从输入流中读取字节放入字节数组b中并返回实际读取的字节数。
int read(byte[] b, int off, int len) 从流中读取len个字节存入字节数组b从off开始的位置中，并返回实际读取的字节数。
long skip(long n) 从流中当前的位置跳过n个字节。
int available() 返回可以从流中读取的字节数。
void close() 关闭输入流。
void mark(int readlimit) 在流中当前位置处做一个标记。以便其后使用reset()方法返回该点。如果在做了标记之后又从流中读取了超过readlimit个字节，则标记无效。
void reset() 将读取位置返回到标记的位置。如果之前没做标记或该流不支持标记将抛出异常。
boolean markSupported() 测试该流是否支持标记。
注意：读取字节流的方法都引入了异常处理，如果遇到读错误，将抛出一个IOException 异常；如果遇到对象为null，则抛出NullPointerException异常；如果使用数组超出范围，则抛出IndexOutOfBoundsException异常。
2）使用字节输入流
如前所述，使用字节输入流的操作需要创建ImputStream子类的对象来实现。下边我们先介绍一下DataInputStream子类，然后再举一个例子，说明一下字节输入流的操作。
2
（1）DataInputStream构造方法
DataInputStream(InputStream in) 用基本的InputStream对象in创建对象。
（2）DataInputStream常用方法
除了继承父类的所有方法之外，还实现了DataInput接口中所有的方法，这些方法主要是读取各类数据，除了读取八种(boolean,byte,char,short,int,float,long, double) 基本类型数据的方法外，还有如下方法：
int readUnsignedByte() 以无符号字节数的方式读取流中的数据。
int readUnsignedShort() 以无符号短整数的方式读取流中的数据。
String readUTF() 以UTF-8数据格式读取流中的数据。
static String readUTF(DataInput in) 以UTF-8数据格式读取由in指定流中的数据。
int skipBytes(int n) 跳读n个字节。
（3）应用举例
例12.1 从键盘上输入5个字节数据放入字节数组中并显示出来。
/* 程序名ByteInputStreamApp.java*/
import java.io.*;
public class ByteInputStreamApp
{
public static void main(String [] args)
{
byte byteArray[]=new byte[5]; //定义字节数组
DataInputStream data=new DataInputStream(System.in);//创建对象
try //捕获I/O错误
{
System.out.print("从键盘上输入5个字节数据:");
data.read(byteArray); //从键盘上输入字节数据放入数组中
}
catch(IOException e)
{
System.out.println(e.toString()); //输出出错信息
}
System.out.print("从流中获取的5个字节数据: ");
for(int i=0;i<5;i++) System.out.print(byteArray[i]+" ");
System.out.println("");
}
}
在程序中，我们使用System.in创建数据输入流对象，如前所述System.in既是System 类的一个属性成员也是一个InputStream对象。
另外，我们使用了try~catch捕获异常机制的语句，主要是捕获data.read (byteArray)语句执行过程中可能发生的I/O错误，这是系统要求的，对于所有涉及流输入和输出的语句都必须对可能出现的错误进行捕获的处理，如果没有捕获错误的处理，系统在编译时将给出错误
3
提示，程序编译未能获得通过。
编译、运行上边的程序，结果如图12.1所示。程序运行时，我们从键盘上输入5
个字
符，它们被放入字节数组中，输出它们的值，它们以ascii码值的形式展现在我们面前。
图12.1 例12.1运行结果
2. 字节输出流（OutputStream）
与InputStream类似，OutputStream是字节输出流的顶层类，它也是一个抽象类。OutputStream类的派生结构如下：
|-class java.io.OutputStream
|-class java.io.ByteArrayOutputStream
|-class java.io.FileOutputStream
|-class java.io.FilterOutputStream
|-class java.io.BufferedOutputStream
|-class java.io.DataOutputStream
|-class java.io.PrintStream
|-class java.io.ObjectOutputStream
|-class java.io.PipedOutputStream
OutputStream类中定义了用来完成从输出流输出数据的—系列方法。下边简要介绍一些常用的方法及其应用。
1）OutputStream类常用方法
abstract void write(int b) 将b的低位字节写入到输出流。这是一个抽象方法，需要在其子类中实现它。
void write(byte[] b) 把字节数组b写入输出流。
void write(byte[] b,int off,int len) 把字节数组b中从off位置开始的len个字节写入输出流。
void flush() 立即将流缓冲区中的数据输出。正常情况下，写入数据到输出流时，write()方法并不能将数据直接写到与输出流相连的设备上，而是先存放在流缓冲区中，等到缓冲区中的数据积累到一定数量时才写到设备上。这样处理可以降低计算机对设备的读写次数，提高系统的效率。但是某些情况下，缓冲区中的数据不满时就需要将它写到设备上，诸如数据的写入已经完成、关闭输出流之前等，均应执行flush()方法。
void close() 关闭输出流。该方法先执行flush()方法把缓冲区中的数据写到流设备上，然后再关闭输出流。
注意：与InputStream类似，写入字节流的方法也都引入了异常处理，如果遇到写错误，将抛出一个IOException异常。
4
2）使用字节输出流
与使用字节输入流类似，使用字节输出流的操作也需要创建OutputStream子类的对象来实现。下边先介绍一下DataOutputStream子类，然后再举一个例子，说明一下字节输出流的操作。
（1）DataOutputStream构造方法
DataOutputStream(OutputStream out) 以OutputStream对象out为参数创建对象。
（2）DataOutputStream常用方法
除了继承父类的所有方法之外，还实现了DataOutput接口中所有的方法，这些方法主要是写入各类数据，除了写入八种(boolean,byte,char,short,int,float,long, double) 基本类型数据的方法（writedataType(dataType v)）外，还提供了如下常用方法：
int size() 返回迄今为止写入流中的字节计数。
void writeChars(String s) 将字符串s写入到输出流中。
void writeUTF(String str) 将字符串str以UTF-8格式写入到输出流中。
（3）应用举例
例12.2 修改例12.1，从键盘上输入5个字节数据放入字节数组中并将它写入基本的输出流中。
/* 程序名ByteOutputStreamApp.java*/
import java.io.*;
public class ByteOutputStreamApp
{
public static void main(String [] args)
{
byte byteArray[]=new byte[5]; //定义字节数组
DataInputStream data=new DataInputStream(System.in);//创建对象
DataOutputStream out=new DataOutputStream(System.out);
try //捕获I/O错误
{
System.out.print("从键盘上输入5个字节数据:");
data.read(byteArray); //从键盘上输入字节数据放入数组中
System.out.print("将字节数组写出的结果: ");
out.write(byteArray); //将字节数组写出
}
catch(IOException e)
{
System.out.println(e.toString()); //输出出错信息
}
System.out.println("");
}
}
请读者运行该程序，比较一下它和例12.1的区别之处，进一步加深对字节流的理解。
3. 综合应用举例
字节流中用的最多的是读写文件数据的文件流（FileInputStream和FileOutputStream）和如上所述的读写基本数据的数据流（DataInputStream和DataOutputStream）。
下边我们先简要介绍一下FileInputStream和FileOutputStream类，然后再举两个应用的例子。
1）FileInputStream类
FileInputStream类构造方法如下：
5
FileInputStream(File file) 以file指定的文件对象创建文件输入流。
FileInputStream(FileDescriptor fdObj) 以fdObj指定的文件描述符对象创建文件输入流。
FileInputStream(String name) 以字符串name指定的文件名创建文件输入流。
FileInputStream除了继承父类的方法之外，还提供了如下常用方法：
FileChannel getChannel() 获得与文件输入流相连接的唯一的FileChannel对象。
FileDescriptor getFD() 获得与文件输入流相连接的文件描述符对象。
2）FileOutputStream类
FileOutputStream类构造方法如下：
FileOutputStream(File file) 以file指定的文件对象创建文件输出流。
FileOutputStream(File file, boolean append) 以file指定的文件对象创建文件输出流。如果append为true，则数据被添加到文件的尾部而不是开头。
FileOutputStream(FileDescriptor fdObj) 以fdObj指定的文件描述符对象创建文件输出流。
FileOutputStream(String name) 以字符串name指定的文件名创建文件输出流。
FileOutputStream(String name, boolean append) 以字符串name指定的文件名创建文件输出流。append的作用如上所述。
FileOutputStream 类除了继承父类的方法之外，还提供了如下常用方法：
FileChannel getChannel() 获得唯一的与该文件输出流相连接的FileChannel对象。
FileDescriptor getFD() 获得与该输出流相连接的文件描述符对象。.
3）应用示例
例12.3 使用字节流建立文件并输出文件内容。
/** 程序名 File_Read_Write.java
* 本示例主要演示数据输入/输出流与文件输入/输出流的简单应用
*/
import java.io.*;
public class File_Read_Write
{
public static void main(String[] arguments)
{
byte [] data=new byte[50];
try
{
DataInputStream in=new DataInputStream(System.in);//创建数据输入流对象;
FileOutputStream file=new FileOutputStream("data1.dat");//创建文件输出流 System.out.println("输入不多于50个字符：");
in.read(data); //将键盘上输入的字符读入字节数组
file.write(data); //将字节数组的元素值写入流
file.close(); //关闭文件输出流
in.close(); //关闭数据输入流
FileInputStream file1=new FileInputStream("data1.dat");//创建文件输入流 DataOutputStream out=new DataOutputStream(System.out); //创建数据输出流 int n=file1.read(data); //从文件输入流中读取数据放入字节数组中
System.out.println("从文件中读取的"+n+"字节的数据如下:");
out.write(data);
file1.close(); //关闭文件输入流
out.close(); //关闭数据输出流
6
catch (IOException e) { System.out.println("Error - " + e.toString()); } }
}
例12.4 使用文件输入/输出流复制文件。
/* 程序名FileCopy.java */
import java.io.*;
public class FileCopy
{
public static void main(String[] arguments)
{
byte [] data=new byte[50];
int n=0;
try
{ //创建文件输入流对象
FileInputStream file1=new FileInputStream("File_Read_Write.class");
//创建文件输出流对象
FileOutputStream file2=new FileOutputStream ("File_Read_Write2.class");
while((n=file1.available())>0) //当文件中还有字节可读时
{
file1.read(data); //将文件的内容读入字节数组
if(n>=50) { file2.write(data); } //若文件没有读完,将读取的整个数组内容写入 else { file2.write(data,0,n); } //将最后的n个字节写入
}
file2.close(); //关闭文件输出流
file1.close(); //关闭文件输入流
}
catch (IOException e) { System.out.println("Error-" + e.toString()); } System.out.println("File_Read_Write.class复制到File_Read_Write2.class完成!");
}
}
12.1.3 字符流
下边简要介绍字符输入流和字符输出流的功能和应用。
1. 字符输入流（Reader类）
Reader类是一个抽象类，是字符输入流的顶层类。Reader类的派生结构如下：
|-class java.io.Reader
|-class java.io.BufferedReader
|-class java.io.LineNumberReader
|-class java.io.CharArrayReader
|-class java.io.FilterReader
|-class java.io.PushbackReader
|-class java.io.InputStreamReader
|-class java.io.FileReader
|-class java.io.PipedReader
|-class java.io.StringReader
7
尽管不能直接创建Reader对象进行流的操作，但Reader类提供了读取字符流的常用方法。下边我们介绍Reader类的功能和使用其子类对象操作字符流的应用。
1）Reader类的方法
Reader类定义了如下常用的方法：
int read() 从流中读取一个字符并将它作为一个int 值返回。如果读到流的结束位置，将返回-1。
int read(char[] cbuf) 将从流中读取字符放入字符数组cbuf中，并返回读取的字符数。
abstract int read(char[] cbuf,int off,int len) 从流中读取len个字符放入cbuf数组中从off 位置开始的元素中。这是一个抽象方法，在其子类中实现它。
long skip(long n) 跳过流中n个字符并返回跳过的字符数。如果流中字符个数小于n，则返回值小于n。.
boolean ready() 测试该流是否已准备好可以读取。如果已准备好，返回true；否则返回false。
boolean markSupported() 测试该流是否可标记的。如果是可标记的，返回true；否则返回false。
void mark(int readAheadLimit) 在流中标记当前位置，readAheadLimit指定在不丢失当前标记位置记录的情况下允许读取的最大字符数。
void reset() 将流的读取位置定位到前一个标记位置，如果没有标记，则定位到流的开始位置。
abstract void close() 关闭字符输入流。这是一个抽象方法，在其子类中实现它。
2）使用字符输入流
如前所述，必须创建Reader类的子类对象来操作字符流。一般我们常使用字符输入流来处理文本文件，FileReader类用于从一个文件中读取字符流。如果想一次在流中读取一行字符时，BufferReader类具有更高的效率。下边先简单介绍一下常用子类的功能，然后再加以应用。
（1）BufferReader类
BufferReader类构造方法如下：
BufferedReader(Reader in) 创建一个系统默认大小的缓冲字符流。
BufferedReader(Reader in, int size) 创建一个由size指定大小的缓冲字符流。
除了继承父类的方法之外，BufferReader还提供了如下常用方法：
String readLine() 读取一行文本。如果已无字符可读即已到流的结尾，将返回null。一般来说，每一行的结束标记是以换行(…\n?)或回车(…\r?)或回车换行(…\r\n?)符表示。
（2）InputStreamReader和FileReader类
InputStreamReader的常用构造方法如下：
InputStreamReader(InputStream in)使用系统默认的字符集构建输入流。
InputStreamReader(InputStream in,Charset cs)使用cs指定的字符集构建输入流。
InputStreamReader(InputStream in, String charsetName)使用charsetName表示的字符集构建输入流。
8
InputStreamReader继承了父类的功能且实现了父类的抽象方法。自身定义了如下方法：String getEncoding() 返回字符编码的名字。
FileReader类是InputStreamReader的派生类，它的构造方法如下：
FileReader(File file) 以file指定的文件创建文件输入流。
FileReader(FileDescriptor fd) 以fd文件描述符指定的文件创建文件输入流。
FileReader(String fileName) 以字符串fileName表示的文件创建文件输入流。
FileReader类继承父类的方法，自身没有定义方法。
（3）应用举例
例12.5 使用字符输入流的方法将例12.4的FileCopy.java程序文件的代码读出并显示。
//TextFileDisplay.java
import java.io.*;
public class TextFileDisplay
{
public static void main(String[] arguments)
{
try
{
BufferedReader buff=new BufferedReader(new FileReader("FileCopy.java"));
String line;
while((line=buff.readLine())!=null) System.out.println(line);
buff.close();
}
catch (IOException e){ System.out.println("Error: " + e.toString()); } }
}
2. 字符输出流（Writer类）
与Reader类一样，Writer类是字符输出流的顶层类，它也是一个抽象类。Writer类的派生结构如下：
|-class java.io.Writer
|-class java.io.BufferedWriter
|-class java.io.CharArrayWriter
|-class java.io.FilterWriter
|-class java.io.OutputStreamWriter
|-class java.io.FileWriter
|-class java.io.PipedWriter
|-class java.io.PrintWriter
|-class java.io.StringWriter
下边简要介绍一下Writer类的功能及其应用。
1) Writer类的方法
Writer类定义了如下操作字符输出流的方法：
void write(int c) 将一个字符写入流中。该字符是由整数c后两个字节的值表示。
void write(char[] cbuf) 将字符数组cbuf的内容写入流中。
abstract void write(char[] cbuf,int off,int len) 将数组cbuf中从off位置开始的len个字符写入流中。这是一个抽象方法，在子类中实现它。
9
10
图12.2 程序用户界面
void write (String str) 将字符串str 写入流中。
void write (String str,int off,int len) 将字符串str 中从off 位置开始的len 个字符写入流中。 abstract void flush () 将流缓冲区中的内容立即输出。这是一个抽象方法，在子类中实现它。
abstract void close () 关闭流。这是一个抽象方法，在子类中实现它。
2) 使用字符输出流
在使用字符流之前，先介绍两个派生类BufferedWriter 和OutputStreamWriter 。
（1）BufferedWriter 类
BufferedWriter 类的构造方法如下：
BufferedWriter (Writer out) 以系统默认的缓冲大小创建字符输出流。
BufferedWriter (Writer out, int size) 以size 指定的缓冲大小创建字符输出流。
BufferedWriter 除了继承父类的功能且实现了父类的抽象方法外。自身定义了如下方法： void newLine () 写入一个行分隔符。
（2）OutputStreamWriter 和FileWriter 类
OutputStreamWriter 类常用的构造方法如下：
OutputStreamWriter (OutputStream out) 以系统默认的字符编码创建输出流。
OutputStreamWriter (OutputStream out, Charset cs) 以cs 指定的字符集创建输出流。 OutputStreamWriter (OutputStream out,String charsetName) 以charsetName 指定的字符集创建输出流。
OutputStreamWriter 除了继承父类的功能且实现了父类的抽象方法外。自身定义了如下方法：
String getEncoding () 获得字符编码名。
FileWriter 类是OutputStreamWriter 的派生类。它继承了父类的所有功能，自身没有定义新方法。它的构造方法如下：
FileWriter (File file) 以文件对象file 构建输出流。
FileWriter (File file, boolean append) 以文件对象file 构建输出流。若append 为true ，在流的尾部添加数据，否则在流的开头写入数据。
FileWriter (FileDescriptor fd) 以文件描述符fd 关联的文件构建输出流。
FileWriter (String fileName) 以fileName 表示的文件构建输出流。
FileWriter (String fileName, boolean append) 以fileName 表示的文件构建输出流。若append 为true ，在流的尾部添加数据，否则在流的开头写入数据。
我们常用FileWriter 类的功能将一个字符流写入到文本文件中。创建一个FileWriter 对象，就可将输出流对象与一个文本文件相关联。
（3）应用举例
下边我们举一个图形界面的例子说明文件
字符流的读写。
例12.6 设计如图12.2的用户界面，编辑简
单文本文件并存储文件。
程序的基本设计思想如下，在用户界面上安
排两个窗格容器JPenal，在第一个窗格上放置一个文本框输入要编辑的文件名；两个按钮：”编辑”按钮用于装入要编辑的文件；”保存”按钮用于保存以编辑好的文件。在第二个窗格上放置一个多行文本框，用于编辑文件内容。
程序代码如下：
/*编辑查看文件程序Editor.java*/
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
public class Editor extends JFrame implements ActionListener
{ JTextField fileName=new JTextField(10);
JTextArea fileContent=new JTextArea(10,40);
JButton editButton=new JButton("编辑");
JButton saveButton=new JButton("保存");;
JPanel panel1=new JPanel();
JPanel panel2=new JPanel();
public Editor()
{
panel1.add(new JLabel("文件名:"));
panel1.add(fileName);
panel1.add(editButton);
panel1.add(saveButton);
panel2.add(fileContent);
this.add(panel1,BorderLayout.CENTER);
this.add(panel2,BorderLayout.SOUTH);
editButton.addActionListener(this);
saveButton.addActionListener(this);
this.pack();
this.setVisible(true);
this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
}
public void actionPerformed(ActionEvent evt)
{
Object obj = evt.getSource();
try
{ if(obj==editButton) //将文件装入文本框
{
FileReader file=new FileReader(fileName.getText());
BufferedReader buff=new BufferedReader(file);
fileContent.setText(""); //在装入之前，设置文本框为空
String line;
while((line=buff.readLine())!=null) fileContent.append(line+'\n');
buff.close(); //装入完成后关闭输入流
}
else if(obj==saveButton)
{
FileWriter file=new FileWriter(fileName.getText());
file.write(fileContent.getText()); //将文本框编辑的内容写入输出流
file.close(); //关闭输出流
JOptionPane.showMessageDialog(null,"文件存储完成!!!","提示信息",JOptionPane.PLAIN_MESSAGE);
}
}
catch(Exception e)
{
JOptionPane.showMessageDialog(null,"文件错误:"+e,"提示信息",JOptionPane.PLAIN_MESSAGE);
}
11
public static void main(String [] args)
{ new Editor(); }
}
以上是一个简单的文本编辑程序，主要是演示字符流的应用。
在学习和掌握上边介绍的这些流类的功能及使用方法之后，对其他的流类，其使用方法和步骤类似，故不再重述。对更多的细节请参考JDK的相关文档。
12.2 文件与随机文件读写
上一节我们讨论了输入输出流的应用，本节将讨论文件的应用和随机文件的读写。12.2.1 文件（File）
Java将操作系统管理的各种类型的文件和目录结构封装成File类，尽管File类位于包java.io中，但它是一个与流无关的类，它主要用来处理与文件或目录结构相关的操作。
1. File类的属性
static final String pathSeparator与系统相关的路径分隔符。为方便起见以字符串形式表示。
static final char pathSeparatorChar与系统相关的路径分隔符。
static final String separator 与系统相关默认的名字分隔符，为方便起见以字符串形式表示。
static final char separatorChar 与系统相关默认的名字分隔符。
在Windows系统下路径分隔符使用“/”或转义字符“\\”。
2. File类的构造方法
File类提供的构造方法如下：
File(String pathname) 用pathname指定的文件或目录路径创建File对象。pathname 指定的路径既可以是绝对路径也可以是相对路径。
File(String parent,String child) 用 parent指定父路径和child指定的子路径创建对象。
File(File parent, String child) 以parent和child创建对象。
File(URI uri) 以uri创建对象。
这里用到了绝对路径和相对路径的概念，所谓绝对路径即完整路径，从逻辑盘的根目录开始所经过的路径，例如：new File(”C:/User1/Java/MyFirstApp.java”)；
所谓相对路径，即是相对于当前目录所经过的路径，一般我们使用”./”表示当前目录，”../”表示当前目录的父目录。例如：new File(”SecondApp.java”);
或：new Fi le(”./SecondApp.java”);均以当前目录上的SecondApp.java建立文件对象。
3. File类的常用方法
File类提供了众多的方法实现各种不同的操作功能，为了方便阅读分类列出如下：
1）测试检查文件对象方法
boolean canExecute() 测试文件是否可以执行。
12
boolean canRead() 测试文件是否可以读取。
boolea canWrite() 测试文件是否可以写入。
boolean exists() 测试对象是否存在。
boolean isAbsolute() 测试对象的引用是否是一个绝对路径。
boolean isDirectory() 测试对象的引用是否是一个目录。
boolean isFile() 测试对象的引用是否是一个文件。
boolean isHidden() 测试对象的引用是否是一个隐藏的文件。
在对一个文件进行相关操作时，一般将进行检查，以确定是否可以执行操作。如果对不能执行的操作强行执行，系统将抛出异常。
2）建立、删除和修改文件对象方法
boolean createNewFile() 利用当前对象定义的路径名建立新文件。若操作成功返回true。
boolean mkdir() 利用当前对象指定的路径生成一个目录。若操作成功返回true。
boolean mkdirs() 生成由当前对象表示的目录，其中包括所需要的父目录。若操作成功返回true。
static File createTempFile(String prefix, String suffix) 建立以prefix指定名字，suffix指定扩展名的临时文件。
boolean delete() 删除由当前对象表示的文件或目录。不能删除非空的目录，要想删除一个目录，必须先删除该目录下的所有文件，而后再删除该目录。若操作成功返回true。
void deleteOnExit() 当程序结束时，删除当前File对象表示文件或目录。
boolean renameTo(File dest) 当前对象表示的文件，将由dest所表示的名字替代。若操作成功返回true。。
boolean setReadOnly() 把当前对象表示的文件设置为只读。若操作成功返回true。
3）获取文件对象信息的方法
String getAbsolutePath() 获得对象引用的文件或目录的绝对路径。
String getName() 获得对象引用的文件或目录的名字。
String getParent() 获得对象引用的文件或目录的父目录名。
String getPath() 获得对象引用的路径包括文件名或目录名。
long lastModified() 获得对象表示的文件或目录最近一次被修改的时间(以毫秒计)。
long length() 获得对象引用的文件的字节长度。若返回0值，表示是一个目录。
String[] list() 如果当前对象引用的是一个目录，则将该目录下的成员名字放入字符串数组中并返回；如果引用的是一个文件，则返回null。
File[] listFiles() 如果当前对象引用的是一个目录，则以该目录下的成员生成File对象放入对象数组中并返回；如果引用的是一个文件，则返回null。
static File[] listRoots() 以根目录下的成员生成File对象放入对象数组中并返回，这是一个类方法。
限于篇幅，上边只列出了一些常用的方法，还有一些没有列出，需要时请参阅JDK文档。
3. File对象的应用
在介绍了文件的上述基本功能之后，下边举两个例子说明File类的具体应用。
例12.7 从键盘上输入一个文件名字，检查该文件是否存在，如果是一个扩展名为.java
13
或.txt的文本文件则输出文件的内容；如果是其他文件则显示其大小，否则显示文件不存在的信息。程序代码如下：
/* 程序名 FileApp1.java */
import java.io.*;
public class FileApp1
{
public void displayTextFile(File fobj) //显示文本文件方法
{try
{BufferedReader buff=new BufferedReader(new FileReader(fobj));
String line;
while((line=buff.readLine())!=null) System.out.println(line);
buff.close();
}
catch (IOException e)
{System.out.println("Error: " + e.toString()); }
}
public static void main(String args[])
{try
{BufferedReader buf=new BufferedReader(new InputStreamReader (System.in));
System.out.print("请输入一个文件名：");
String fileName=buf.readLine(); //从键盘上输入文件名
File userFile=new File(fileName); //创建File对象
if(userFile.isFile())
{ if(fileName.endsWith(".java")||fileName.endsWith(".txt"))
{ new FileApp1().displayTextFile(userFile); } //调用方法显示文件内容 else
{ System.out.println(fileName+"文件大小"+userFile.length());}
}
else
{ System.out.println(fileName+"不是一个文件"); }
}
catch(IOException e) { System.out.println(e.toString()); }
}
}
例12.8 在当前的目录下建立一个子目录java_prg，将当前目录下的Java源程序文件复制到新建子目录下。程序代码如下：
/* 程序名 FileApp2.java */
import java.io.*;
public class FileApp2
{
public void copyFile(File file,String dir)//复制文件方法
{try
{
BufferedReader buff=new BufferedReader(new FileReader(file));
FileWriter des=new FileWriter(dir+file.getName());
String line;
while((line=buff.readLine())!=null) des.write(line+"\n");
buff.close();
des.close();
}
catch (IOException e)
{ System.out.println("Error: " + e.toString());}
}
public static void main(String args[])
{
File userFile = new File("./"); //以当前目录创建File对象
14
File[] fileArray=userFile.listFiles();//将当前目录下的文件作为对象放入数组 FileApp2 thisobj=new FileApp2(); //创建本类对象
int n=0;
for(int i=0; i { String fileName=fileArray[i].getName(); if(fileName.endsWith(".java")) { thisobj.copyFile(fileArray[i],"./java_prg/"); n++; } } System.out.println("总共有"+n+"个文件被复制!!!") ; } } 请读者认真阅读上述程序，加深理解文件的应用并仿照上边的例子编写出文件删除及其他应用的程序。编译、运行程序并查看执行结果。 12.2.2 文件对话框(FileDialog) 在选择打开文件和保存文件的人机会话中，常常使用文件对话框。 1．构造方法 构造文件对话框对象的常用方法如下： FileDialog(Frame parent)依附于parent窗口创建一个文件对话框。 FileDialog(Frame parent,String title)依附于parent窗口以title为标题创建对象。 FileDialog(Frame parent,String title,int mode) 创建文件对话框，其中mode指定对话框的方式，可以取如下类常数： FileDialog.LOAD 表示打开文件对话框； FileDialog.SA VE 表示保存文件对话框。 2．对象常用方法 public String getDirectory()获取当前文件对话框中所显示对象的目录。 public void setDirectory(String dir)将dir指定的目录设置为对话框中显示的目录。 public Stirng getFile()获取对话框中选定的文件的名称。 public void setFile(String file)将file指定的文件设置为对话框中默认选定文件。 3. 应用举例 在实际应用中，我们常常需要查看、修改、备份一些程序文件或文本文件，下边举一个例子说明文件对话框的使用。 例12.9 设计如图12.3的用户Array界面，当单击“编辑文件”按钮时， 显示打开文件对话框，选择要编辑 的文件，并将选中的文件装入多行 文本框供查看和编辑；当单击“保 存文件”按钮时，显示保存文件对 话框，指定文件的名字，便将文本 框中的内容保存到指定的文件中。 图12.3 文件对话框示例程序界面 15 一旦选中或指定了文件，就在标签中显示该文件名。 程序的基本设计思想是，在用户输入界面上放置一个标签用于显示操作的文件名及信息；放置两个按钮用于打开文件和保存文件；一个多行文本框用于显示和编辑文件的内容。为了布局的方便，增加一个窗格容器(Panel)将两个按钮摆放到上边，所有布局都采用流布局。程序参考代码如下： import java.io.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; class File_Dialog extends JFrame implements ActionListener { Button bt1,bt2; TextArea text=new TextArea(12,70); Label lb1=new Label("执行下列操作",1); FileDialog fileLoad,fileSave; public File_Dialog() { bt1=new Button("编辑文件"); bt2=new Button("保存文件"); Container pane=this.getContentPane(); fileLoad=new FileDialog(this,"打开文件对话框",FileDialog.LOAD); fileSave=new FileDialog(this,"保存文件对话框",FileDialog.SAVE); pane.setLayout(new FlowLayout()); JPanel p1=new JPanel(); p1.add(bt1); p1.add(bt2); bt1.addActionListener(this); bt2.addActionListener(this); pane.add(lb1); pane.add(p1); pane.add(text); this.setTitle("文件对话框示例"); this.setVisible(true); this.setSize(600,300); this.setDefaultCloseOperation(3); } public void actionPerformed(ActionEvent e) { if(e.getSource()==bt1) { fileLoad.setVisible(true); String dir=fileLoad.getDirectory(); String name=fileLoad.getFile(); if (name==null) { lb1.setText("你没有选定要编辑的文件:"); return;} lb1.setText("编辑文件："+dir+name); try { BufferedReader buff=new BufferedReader(new FileReader(dir+name)); String line; while((line=buff.readLine())!=null) text.append(line+'\n'); buff.close(); } catch(IOException ee) { lb1.setText(ee.toString()); } } else if (e.getSource()==bt2) { fileSave.setVisible(true); String dir=fileSave.getDirectory(); 16 if (name==null) { lb1.setText("你没有输入(选定)输出文件名!"); return; } lb1.setText("保存文件的路径为"+dir+"文件名为"+name); try { FileWriter file=new FileWriter(dir+name); //建立输出文件 file.write(text.getText()); //将文本框编辑的内容写入输出流 file.close(); //关闭输出流 } catch(IOException ee) { lb1.setText(ee.toString()); } } } public static void main(String args[]) { new File_Dialog(); } } 请读者编译运行上述程序，检验程序的功能，掌握文件对话框的应用。 12.2.3 随机文件的读写 前面我们介绍的文件读写，都是按照顺序的方式进行读写，即从文件的起始位置顺序地读写到文件的结束位置。有时候，我们希望直接获取某一指定位置的内容或将内容直接写入到指定的位置，使用顺序读写的方式显然比较麻烦。Java在java.io包中提供了RandomAccessFile类，用于处理随机读取的文件。 下边我们简要介绍一下RandomAccessFile类的功能及应用。 1. RandomAccessFile类的构造方法 RandomAccessFile类的构造方法如下： RandomAccessFile(File file，String mode) 以file指定的文件和mode指定的读写方式构建对象。 RandomAccessFile(String name，String mode) 以name表示的文件和mode指定的读写方式构建对象。 读写方式有如下几种： 1）“r”读方式。用于从文件中读取内容。 2）“rw”读写方式。既可从文件中读取内容也可向文件中写入内容。 3）“rwd”读写方式。每一次文件内容的修改被同步写入存储设备上。 4）“rws”读写方式。每一次文件内容的修改和元数据被同步写入存储设备上。 例如，创建一个读方式的随机文件对象： RandomAccess rFile1=new RandomAccess(new File(“data1.dat”),”r”); 创建一个读写方式的随机文件对象： RandomAccess rFile2=new RandomAccess(“data2.dat”,”r w”); 2. RandomAccessFile类的常用方法 RandomAccessFile类提供了众多的方法，为了便于阅读比较，我们以如下方式列出：1）读写方法 17 18 图12.4 用户输入界面 八种基本类型数据对应的读写方法一般格式如下： dataType readDataType () void writeDataType (dataType v) 其中，dataType 、DataType 是八种基本类型之一。所不同的是方法名中的类型字首字母大写，如：readByte 、writeLong 。 应该注意的是除了Long 整型外，其他整数写方法writeByte() 、writeChar （）和writeShort()均采用int 参数。 除了八种基本类型数据对应的读写方法外，其他的读写方法如下： int readUnsignedByte () 读入一个无符号字节数。 int readUnsignedShort () 读入一个无符号短整数。 int read (byte[] b) 从文件中读取内容，放入一个字节数组b 中。 int read (byte[] b,int off,int len) 从文件中读取len 字节，放入数组b 从off 开始的位置中。 String readUTF () 以UTF-8格式从文件中读取字符串。 String readLine () 从文本文件中读取一行文本。 void write (byte[] b) 将字节数组b 写入文件中。 void write (byte[] b,int off,int len) 将数组从off 位置开始的len 个元素值写入文件。 void writeChars (String s) 以字符格式把字符串s 写入文件。 void writeBytes (String s) 以字节格式把字符串s 写入文件。 void writeUTF (String str) 以UTF-8格式把字符串str 写入文件。 2）有关文件位置方法 long getFilePointer () 获得文件的当前位置。 void seek (long pos) 定位文件到pos 位置。 int skipBytes (int n) 从当前位置跳过n 个字节。 3）其他方法 void setLength (long newLength) 设置文件长度。 long length () 获得文件的长度。 void close () 关闭文件。 FileChannel getChannel () 获得对象的文件通道。 FileDescriptor getFD () 获得对象的文件描述符。 3. 应用举例 例12.10 设计如下界面（图12.4）的学生登记程序，并将登记输入的学生姓名、学号存入随机存取文件student.txt 中。 程序的基本设计思想是，在用户输入界 面上放置两个文本框，用于输入姓名和学 号；放置两个按钮，一个用于将文本框中的 学生信息写入随机文件中，另一个用于结束 程序运行。程序代码如下： /* 程序名Login.java */ import java.awt.*; import javax.swing.*; import java.awt.event.*; public class Login extends JFrame implements ActionListener { JTextField tStudentName; //定义学生名字 JTextField tStudentNo; //定义学号 JButton okButton,exitButton; //定义操作按钮 RandomAccessFile logFile; public Login() //构造方法 { this.setLayout(new GridLayout(3,2)); tStudentName = new JTextField(10); tStudentNo = new JTextField(10); okButton = new JButton("登记"); exitButton=new JButton("退出"); this.add(new JLabel("姓名")); this.add(tStudentName); this.add(new JLabel("学号")); this.add(tStudentNo); this.add(okButton); this.add(exitButton); okButton.addActionListener(this); exitButton.addActionListener(this); try { logFile=new RandomAccessFile("student.txt","rw"); } catch(IOException e) { JOptionPane.showMessageDialog(null,"文件错误:"+e,"提示信息",JOptionPane.PLAIN_MESSAGE); } this.pack(); this.setVisible(true); this.setDefaultCloseOperation(this.EXIT_ON_CLOSE); }//构造方法结束 public void actionPerformed(ActionEvent evt) //实现事件接口的方法 { Object obj = evt.getSource(); try {if(obj==okButton) //若点击了登记按钮 { String str1=tStudentName.getText()+"－－－"; //取姓名值 String str2=tStudentNo.getText()+" "; //取学号值 logFile.seek(logFile.length()); //定位到文件尾 logFile.writeUTF(str1.substring(0,5)); //写入姓名 logFile.writeUTF(str2.substring(0,11)); //写入学号 tStudentName.setText(""); } else //若点击了退出按钮 { logFile.close(); //关闭文件 System.exit(0); //退出程序 } } catch(IOException e){ System.out.println("Error:"+e); } } //实现事件接口的方法结束 public static void main(String [] args) { new Login(); } //main()方法结束 } 注意：由于汉字编码和其他字符编码不一样，为了能够正确地随机获取每个学生的信息， 19 必须保证名字串的长度一致和学号串的长度一致，因此在程序中进行了相关的处理。 例12.11 从运行上例建立的随机存取文件student.txt中，抽查某位学生的信息，检验随机文件的读取功能。程序代码如下： /* 程序名CheckStudent.java */ import java.io.*; public class CheckStudent { public static void main(String [] args) { try { BufferedReader in= new BufferedReader(new InputStreamReader(System.in)); RandomAccessFile logFile=new RandomAccessFile("student.txt","r"); System.out.print("输入要查找学生的序号:"); long n=Long.parseLong(in.readLine()); //从键盘上输入序号 logFile.seek((n-1)*30);//定位要查找的位置 System.out.print(logFile.readUTF()); //输出姓名 System.out.println(logFile.readUTF());//输出学号 in.close(); //关闭输入流 logFile.close(); //关闭随机文件 } catch(IOException e) { System.out.println("ERROR:"+e); } } } 请读者编译运行上述程序，输入相应的数据，检验程序的正确性。 12.3 数据库（DataBase） 前边我们介绍了数据流及其文件的应用，使用文件处理了一些简单数据结构类型的数据。在实际应用中，经常会遇到一些比较复杂的数据结构对象，诸如企业的应用系统、学生注册系统、联机考试系统等等，都需要处理大量复杂的数据信息，这就需要使用数据库进行处理。数据库文件中可以存放复杂的相关信息的集合，使用数据库管理系统——DBMS(DataBase Manage System)就可以方便地对数据库中的数据进行检索、添加和修改。DBMS有很多种，当前最常用的是关系数据库管理系统——（Relational DataBase Manage System），MS-SQL Server、MS-Access、Oracle、Informix等等都属于RDBMS。 本节并不专门介绍DBMS的知识，而是重点介绍在Java环境中如何使用数据库，对数据库中的数据进行查询（检索）、添加与修改的方法。 12.3.1 JDBC技术 JDBC(Java DataBase Connectivity)是一套访问数据库的接口，它为数据库应用的开发人员提供了一组用于执行SQL语句操作数据库的标准API。 我们知道，不同数据库可能使用不同的数据格式和不同的操作语法，没有一定的经验要想正确地操作各种数据库是比较困难的，要求每个程序设计者熟知各数据库的操作方法也是不太现实的（因为将耗费大量的时间），其实也是毫无意义的。因为使用JDBC，我们只需要了解SQL语句的语法及功能，而不必关心使用哪个数据库（Sybase、MS-SQL Server、 20 I/O类体系 在JDK API中，基础的IO类都位于java.io包，而新实现的IO类则位于一系列以java.nio开头的包名中，这里首先介绍java.io包中类的体系结构。 按照前面的说明，流是有方向的，则整个流的结构按照流的方向可以划分为两类： 1、输入流： 该类流将外部数据源的数据转换为流，程序通过读取该类流中的数据，完成对于外部数据源中数据的读入。 2、输出流： 该类流完成将流中的数据转换到对应的数据源中，程序通过向该类流中写入数据，完成将数据写入到对应的外部数据源中。 而在实际实现时，由于JDK API历史的原因，在java.io包中又实现了两类流：字节流(byte stream)和字符流(char stream)。这两种流实现的是流中数据序列的单位，在字节流中，数据序列以byte为单位，也就是流中的数据按照一个byte一个byte的顺序实现成流，对于该类流操作的基本单位是一个byte，而对于字节流，数据序列以char为单位，也就是流中的数据按照一个char一个插入的顺序实现成流，对于该类流操作的基本单位是一个char。 另外字节流是从JDK1.0开始加入到API中的，而字符流则是从JDK1.1开始才加入到API中的，对于现在使用的JDK版本来说，这两类流都包含在API的内部。在实际使用时，字符流的效率要比字节流高一些。 在实际使用时，字符流中的类基本上和字节流中的类对应，所以在开始学习IO类时，可以从最基础的字节流开始学习。 在SUN设计JDK的IO类时，按照以上的分类，为每个系列的类设计了一个父类，而实现具体操作的类都作为该系列类的子类，则IO类设计时的四个体系中每个体系中对应的父类分别是： 字节输入流InputStream 该类是IO编程中所有字节输入流的父类，熟悉该类的使用将对使用字节输入流产生很大的帮助，下面做一下详细的介绍。 按照前面介绍的流的概念，字节输入流完成的是按照字节形式构造读取数据的输入流的结构，每个该类的对象就是一个实际的输入流，在构造时由API完成将外部数据源转换为流对象的操作，这种转换对程序员来说是透明的。在程序使用时，程序员只需要读取该流对象，就可以完成对于外部数据的读取了。 什么是流？流有什么用？面向对象语言为什么需要流？哪些场合需要流？ 答：流是指一组有顺序、有起点和终点地字节集合，是对数据传输地总称或抽象（也就是数据在两个对象之间地传输称为流）.个人收集整理勿做商业用途 流地作用就是使数据传输操作独立于相关设备. 在面向对象地程序设计中，数据地传输和流动具有广泛性，可以在内存与外部设备之间传输，还可以从内存到内存，甚至可以从一台计算机通过网络流向另一台计算机等，故面向对象语言采用流机制.个人收集整理勿做商业用途 在标准输入输出、在文件地读写等操作中都需要流. 提供了哪些流类？各种流类之间地关系是怎样地？什么场合需要使用什么流类？ 答：中按照流地方向性，流分为输入流和输出流两大类.按照流中元素地基本类型，流分为字节流和字符流两大类.字节流类按照流地方向分为字节输入流类和字节输出流类，字符流类方向性分为字符输入流类和字符输出流类.以及文件操作类，随机存取文件类.个人收集整理勿做商业用途 其中类是所有字节输入流地根类，类是所有字节输出流地根类；类是所有字符输入流地根类，类是所有字符输出流地根类.个人收集整理勿做商业用途 操作系统中文件和目录概念是怎么样地？提供了哪些对文件和目录操作地类？程序中对文件和目录能够进行哪些操作？如何操作？个人收集整理勿做商业用途 答：文件是信息地一种组织形式，是存储在外部存储介质上地具有标识名地一组相关地信息集合.目录是文件系统组织和管理文件地基本单位，保存它所管理地每个文件地基本属性信息（称为文件目录项或文件控制块）.个人收集整理勿做商业用途 直接对文件地顺序存取和随机存取操作，提供了类记载文件属性信息，对文件读写操作时以流地形式.类以随机存取方式进行文件读写操作.但在对文件操作过程中还需要使用文件过滤器接口和文件对话框类.在操作系统中，目录也是以文件地形式保存地，称为目录文件.故一个对象也可以表示一个目录.个人收集整理勿做商业用途 可以对文件进行读、写、删除、创建等操作，对目录可以读取、创建、删除等操作.应用程序通过调用操作系统提供地系统调用能够对文件及目录进行各种操作.个人收集整理勿做商业用途 再打开、保存、复制文件时，需要读写文件中地数据内容，这些操作由流实现，不同类型地文件需要使用不同地流泪.个人收集整理勿做商业用途 流与文件操作有什么关系？实际应用中将流类与文件操作结合起来能够实现哪些复杂问题？如何实现？个人收集整理勿做商业用途 答：对文件地操作时通过流这个工具进行地.再打开、保存、复制文件时，需要读写文件中地数据内容，这些操作由流实现，不同类型地文件需要使用不同地流泪.个人收集整理勿做商业用途 什么是输入输出?什么是标准输入输出？怎样实现标准输入输出功能？ 答：数据由外部设备流向内存，这个过程称为输入；数据有内存流向外部设备，这个过程称为输出. 在计算机系统中，标准输入是从键盘等外部输入设备中获得数据，标准输出是向显示器或打印机等外部输出设备发送数据.个人收集整理勿做商业用途 在类中声明了个常量、和用于实现标准输入输出功能.个人收集整理勿做商业用途除了标准输入输出及文件操作之外，还有那些应用中需要使用流？ 答：在面向对象地程序设计中，数据地传输和流动具有广泛性，不仅可以在内存与外部设备之间传输，还可以从内存流向内存，甚至可以从一台计算机通过网络流向另一台计算机，因此各种不同地数据源地传输都需要采取不同地流机制来实现.个人收集整理勿做商业用途 文件流是以外存文件为输入输出对象的数据流，字符串流不是以外存文件为输入输出的对象，而以内存中用户定义的字符数组(字符串)为输入输出的对象，即将数据输出到内存中的字符数组，或者从字符数组(字符串)将数据读入。字符串流也称为内存流。 字符串流也有相应的缓冲区，开始时流缓冲区是空的。如果向字符数组存入数据，随着向流插入数据，流缓冲区中的数据不断增加，待缓冲区满了(或遇换行符)，一起存入字符数组。如果是从字符数组读数据，先将字符数组中的数据送到流缓冲区，然后从缓冲区中提取数据赋给有关变量。 在字符数组中可以存放字符，也可以存放整数、浮点数以及其他类型的数据。在向字符数组存入数据之前，要先将数据从二进制形式转换为ASCII代码，然后存放在缓冲区，再从缓冲区送到字符数组。从字符数组读数据时，先将字符数组中的数据送到缓冲区，在赋给变量前要先将ASCII代码转换为二进制形式。总之，流缓冲区中的数据格式与字符数组相同。这种情况与以标准设备（键盘和显示器）为对象的输入输出是类似的，键盘和显示器都是按字符形式输入输出的设备，内存中的数据在输出到显示器之前，先要转换为ASCII码形式，并送到输出缓冲区中。从键盘输入的数据以ASCII码形式输入到输入缓冲区，在赋给变量前转换为相应变量类型的二进制形式，然后赋给变量。对于字符串流的输入输出的情况，如不清楚，可以从对标准设备的输入输出中得到启发。 文件流类有ifstream,ofstream和fstream,而字符串流类有istrstream,ostrstream和strstream。文件流类和字符串流类都是ostream,istream和iostream类的派生类,因此对它们的操作方法是基本相同的。向内存中的一个字符数组写数据就如同向文件写数据一样,但有3点不同： 1. 输出时数据不是流向外存文件，而是流向内存中的一个存储空间。输入时从内存中的存储空间读取数据。在严格的意义上 说，这不属于输入输出，称为读写比较合适。因为输入输出一般指的是在计算机内存与计算机外的文件（外部设备也视为文件）之间的数据传送。但由于C++的字符串流采用了C++的流输入输出机制，因此往往也用输入和输出来表述读写操作。 2. 字符串流对象关联的不是文件,而是内存中的一个字符数组,因此不需要打开和关闭文件。 3. 每个文件的最后都有一个文件结束符,表示文件的结束。而字符串流所关联的字符数组中没有相应的结束标志,用户要指定 一个特殊字符作为结束符,在向字符数组写入全部数据后要写入此字符。 字符串流类没有open成员函数，因此要在建立字符串流对象时通过给定参数来确立字符串流与字符数组的关联。即通过调用构造函数来解决此问题。建立字符串流对象的方法与含义如下。 建立输出字符串流对象 ostrstream类提供的构造函数的原型为： ostrstream::ostrstream(char *buffer,int n,int mode=ios::out); buffer是指向字符数组首元素的指针，n为指定的流缓冲区的大小（一般选与字符数组的大小相同，也可以不同），第3个参数是可选的，默认为ios::out方式。可以用以下语句建立输出字符串流对象并与字符数组建立关联： ostrstream strout(ch1,20); 作用是建立输出字符串流对象strout，并使strout与字符数组ch1关联（通过字符串流将数据输出到字符数组ch1），流缓冲区大小为20。 建立输入字符串流对象 istrstream类提供了两个带参的构造函数，原型为： istrstream::istrstream(char *buffer); istrstream::istrstream(char *buffer,int n); buffer是指向字符数组首元素的指针，用它来初始化流对象（使流对象与字符数组建立关联）。可以用以下语句建立输入字符串流对象： istrstream strin(ch2); 作用是建立输入字符串流对象strin，将字符数组ch2中的全部数据作为输入字符串流的内容。 istrstream strin(ch2,20); 流缓冲区大小为20，因此只将字符数组ch2中的,20个字符作为输入字符串流的内容。 建立输入输出字符串流对象 strstream类提供的构造函数的原型为： strstream::strstream(char *buffer,int n,int mode); 可以用以下语句建立输入输出字符串流对象： 第三章数据库基本操作 一、选择题 1. 如果需要给当前表增加一个字段，应使用的命令是________。 A) APPEND B) INSERT C) EDIT D) MODIFY STRU 2. 设表文件及其索引已打开，为了确保指针定位在物理记录号为1的记录上，应该使用命令________。 A) SKIP 1 B) SKIP -1 C) GO 1 D) GO TOP 3. 要显示数据库中当前一条记录的内容，可使用命令________。 A) LIST B) BROWSE C) TYPE D) DISPLAY 4. 在当前表中，查找第2个女同学的记录，应使用命令________。 A) LOCATE FOR 性别="女" B) LOCATE FOR 性别="女" NEXT 2 C) LIST FOR 性别="女" CONTINUE D) LOCATE FOR 性别="女" CONTINUE 5. Visual FoxPro的数据库表之间可建立两种联系，它们是________。 A) 永久联系和临时联系B) 长期联系和短期联系 C) 永久联系和短期联系D) 长期联系和临时联系 6. 数据库表的索引中，字段值不能有重复的索引有________种。 A) 1 B) 2 C) 3 D) 4 7. 建立表间临时关联的命令是________。 A) LET RELATION TO命令 B) JOIN命令 C) SET RELATION TO命令 D) 以上都不是 8. 通过关键字建立表间的临时关联的前提是________。 A) 父表必须索引并打开B) 子表必须索引并打开 C) 两表必须索引并打开D) 两表都不必索引 9. 查询设计器的“筛选”选项卡上，“插入”按钮的作用是________。 A) 用于增加查询输出字段B) 用于增加查询的表 C) 用于增加查询去向D) 用于插入查询输出条件 10. 在多工作区的操作中，如果选择了4，7，8号工作区并打开了相应的数据库，在命令窗口执行命令SELECT 0，其功能是________。 A) 选择4号工作区为当前工作区B) 选择0号工作区为当前工作区 C) 选择7号工作区为当前工作区D) 选择8号工作区为当前工作区 11. 表结构中空值（NULL）的含义是________。 A) 空格B) 尚未确定 Java IO流和文件操作Java流操作有关的类或接口： Java流类图结构： 1、File类 File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。 构造方法摘要 File(File parent, String child) File(String pathname) File(String parent, String child) 构造函数 创建方法 1.boolean createNewFile() 不存在返回true 存在返回false 2.boolean mkdir() 创建目录 3.boolean mkdirs() 创建多级目录 删除方法 1.boolean delete() 2.boolean deleteOnExit() 文件使用完成后删除 例子1：列出指定文件夹的文件或文件夹 public class FileDemo1 { public static void main(String[] args){ File[] files =File.listRoots(); for(File file:files){ System.out.println(file); if(file.length()>0){ String[] filenames =file.list(); for(String filename:filenames){ System.out.println(filename); } } } } } 例子2：文件过滤 import java.io.File; public class FileTest2 { public static void main(String[] args) { File file = new File("file"); String[] names = file.list(); for(String name : names) { if(name.endsWith(".java")) { System.out.println(name); } 实验五输入输出流 一、实验目的 1.掌握文件的使用 2.掌握字节I/O流、字符类I/O流、缓冲流、数据流等常用流的使用。 3.熟悉对象流、RandomAccessFile类的使用。 二、实验内容 1.利用各种常用IO流的处理方法，编写Java应用程序。 三、实验步骤与要求 第1题文件加密 编写一个Java应用程序，将已存在的扩展名为.txt的文本文件加密后存入另一个文本文件中。 package four; import java.io.*; public class file { public static void main(String args[]) { File readFile =new File("Student.txt"), writeFile =new File("Hello.txt"); String s="欢迎来到北京 welcome"; char b[]=s.toCharArray(); try{ FileWriter out=new FileWriter(readFile,true); out.write(b); out.close(); FileWriter tofile=new FileWriter ("hello.txt"); for(int i=0;i tofile.write(secret); tofile.close(); FileReader inOne=new FileReader("Hello.txt"); int t=0; System.out.println("存入后："); while((t=inOne.read(b,0,2))!=-1) { String str=new String(b,0,2); System.out.println(str); } inOne.close(); } catch (IOException e){ System.out.println(e); } } } 第2题读写基本类型数据 编写一个Java应用程序，将若干基本数据写入到一个文件，然后再按顺序读出。 1．下列流类中可以用于处理文件的是（）。Empty! (D) (a) ios (b) iostream (c) strstream (d) fstream 2．在下列选项中（）是istream类的对象。Empty! (B) (a) cerr (b) cin (c) clog (d) cout 3．read函数的功能是从输入流中读取（）。Empty! (D) (a) 一个字符(b) 当前字符(c) 一行字符(d) 指定若干个字节 4．下列选项中，用于清除基数格式位设置以十六进制输出的语句是（）。Empty! (B) (a) cout << setf( ios::dec, ios::basefield ) ; (b) cout << setf( ios::hex, ios::basefield ) ; (c) cout << setf( ios::oct, ios::basefield ) ; (d) cin >> setf( ios::hex, ios::basefield ) ; 5．下列格式控制符，既可以用于输入，又可以用于输出的是（）。Empty! (A) (a) setbase (b) setfill (c) setprecision (d) setw 6．下列串流类，在strstream.h中定义的是（）。Empty! (B) (a) istringstream (b) istrstream (c) ostringstream (d) stringstream 7．包含类fstream定义的头文件是（）。Empty! (A) (a) fstream.h (b) ofstream.h (c) ifstream.h (d) iostream.h 8．要求打开文件 D:\file.dat，并能够写入数据，正确的语句是（）。Empty! (D) (a) ifstream infile( "D:\\file.dat", ios::in ) ; (b) ifstream infile( "D:\\file.dat", ios::out ) ; (c) ofstream outfile( "D:\\file.dat", ios::in ) ; 第十二章数据库技术新发展 1．试述数据库技术的发展过程。 答： （1）数据模型是数据库系统的核心和基础。数据库技术的三个发展阶段应该按照数据模型的进展来界定。按照数据模型的进展，数据库技术可以相应地分为三个发展阶段。 （2）数据模型的发展经历了格式化数据模型（包括层次数据模型和网状数据模型）、关系数据模型两个阶段，发展到以面向对象数据模型为代表的非传统数据模型的阶段。 （3）读者可以从每一代数据库系统的主要特征、代表性系统、主要成就、优点和不足来了解数据库技术的发展过程。 层次数据库系统和网状数据库系统的数据模型虽然分别为层次模型和网状模型，但实质上层次模型是网状模型的特例。它们都是格式化模型。它们从体系结构、数据库语言到数据存储管理均具有共同特征，是第一代数据库系统。 关系数据库系统支持关系模型。关系模型不仅简单、清晰，而且有关系代数作为语言模型，有关系数据理论作为理论基础。因此，关系数据库系统具有形式基础好、数据独立性强、数据库语言非过程化等特色，标志着数据库技术发展到了第二代。 第二代数据库系统的数据模型虽然描述了现实世界数据的结构和一些重要的相互联系，但是仍不能捕捉和表达数据对象所具有的丰富而重要的语义，因此尚只能属于语法模型。 第三代的数据库系统将以更加丰富的数据模型和更强大的数据管理功能为特征，从而满足传统数据库系统难以支持的新的应用要求。 2．当前数据库技术发展的主要特征是什么？ 答：新一代数据库技术的特点是： (1）面向对象的方法和技术对数据库发展的影响最为深远 数据库研究人员借鉴和吸收了面向对象的方法和技术，提出了面向对象数据模型（简称对象模型）。该模型克服了传统数据模型的局限性，促进了数据库技术在一个新的技术基础上继续发展。 （2）数据库技术与多学科技术的有机结合 计算机领域中其他新兴技术的发展对数据库技术产生了重大影响。传统的数据库技术和其他计算机技术，如网络通信技术、人工智能技术、面向对象程序设计技术、并行计算技术、移动计算技术等的互相结合、互相渗透，使数据库中新的技术内容层出不穷。 （3）面向应用领域的数据库技术的研究 在传统数据库系统基础上，结合各个应用领域的特点，研究适合该应用领域的数据库技术，如数据仓库、工程数据库、统计数据库、科学数据库、空间数据库。地理数据库等，这是当前数据库技术发展的又一重要特征。 解析：可以用一个三维空间的视图，比较清晰地从数据模型、其他计算机技术、应用领域3个方面描述新一代数据库系统及其相互关系。 第12章数据库的启动与关闭 数据库启动时会首先启动数据库实例（instance），在这个过程中数据库获得一些内存空间，并启动了必须的后台进程，而后会读取控制文件再进一步打开各种数据文件，最后完成数据库的启动任务。 在启动数据库时，涉及三种状态：nomount,mount,open,通常使用startup指令选择不同的参数就可以启动数据库到不同的状态来满足不同的业务需要。 关闭数据库和启动数据库正好相反，也涉及三个过程：close,dismount,shutdown。用户可以选择使用不同的参数normal,immediate,transactional,abort.在关闭数据库时，最好使用shutdown immediate方式，这种方式安全且相对较快。 12.1启动数据库 启动数据库需要以DBA用户的身份登录。 12.1数据库的启动过程 数据库的启动过程涉及到三个状态。 NOMOUNT状态：只打开了数据库实例。 NOUNT状态：打开控制文件。 OPEN状态：打开数据文件、日志文件等各类必须的数据库文件。 12.1数据库启动到NOMOUNT状态 搜索参数文件，如数据库缓冲区大小、重做日志缓冲区大小等。根据这些参数分配内存，即SGA，然后启动必须的五个后台进程。 数据库的启动过程记录在告警追踪文件中，存放在BACKGROUND_DUMP_DEST 定义的目录下，名字为aler_orcl.log。 SQL>show parameter background_dump_dest; SQL>select * SQL>from v$controlfile;_________会发现此时控制文件没有打开。 SQL>show parameter control_files; 12.1.3数据库启动到MOUNT状态 有两种方式，一是可以直接启动数据库到MOUNT状态；二是如果数据库已经启动到NOMOUNT状态，使用指令ALTER DATABASE MOUNT把数据库切换到MOUNT 状态。 SQL>select * SQL>from scott.dept;__________会发现些时数据文件没有打开。 12.1.4数据库启动到OPEN状态 ORACLE需要检验数据文件的头信息，进行点计数器检查和SCN检查来完成实例恢复。 数据库启动到OPEN状态，有两种方式，一是直接启动到OPEN状态，使用指令startup open或startup来实现。二是如果数据库处于NOMOUNT或MOUNT状态，可以使用指令alter database open切换到OPEN状态。 实验6 输入输出流操作 一、实验目的 1. 理解数据流的概念 2. 理解Java流的层次结构 3. 理解文件的概念 二、实验要求 1. 掌握字节流的基本使用方法 2. 掌握字符流的基本使用方法 3. 能够创建、读写、更新文件 三、实验练习内容 1. Java的标准输入输出流System.in/System.out 知识点解析: 标准数据流指在字符方式下（如DOS 提示符）程序与系统进行输入输出的方式，键盘和显示器屏幕是标准输入输出设备，数据输入的起点为键盘，数据输出的终点是屏幕，输出的数据可以在屏幕上显示出来。 示例：课本例10.1 2. 文件字节输入输出流类FileInputStream/ FileOutputStream 知识点解析: 文件字节输入输出流主要负责完成对本地磁盘文件的顺序输入与输出操作。示例：课本例10.2 3. 数据字节输入输出流DataOutputStream/DataInputStream 知识点解析: 使用数据输入流DataOutputStream 和数据输出流DataInputStream 可以读取或写入8种基本数据类型的数据，不用关心它们的实际长度是多少字节。一般与文件输入流FileInputStream 和输出流类FileOutputStream 一起使用。 示例：课本例10.3 4. 对象字节输入输出流ObjectInputStream/ ObjectOutputStream 知识点解析: 使用对象流可以直接写入或读取一个对象。由于一个类的对象包含多种信 息，为了保证从对象流中能够读取到正确的对象，因此要求所有写入对象流的对象都必须是序列化的对象。一个类如果实现了Serializable 接口，那么这个类的对象就是序列化的对象。Serializable 接口没有方法，实现该接口的类不需要实现额外的方法。 示例：课本例10.4 5. 文件字符输入输出流FileReader/FileWriter和字符缓冲输入输出流 BufferedReader/BufferedWriter 知识点解析:文件字符输入输出流类与文件字节输入输出流类功能类似，但处理的基本单位是字符。字符缓冲输入输出流类用来对字符流进行成批的处理。 示例：课本例10.5 6. 文件类File 知识点解析: 文件类主要用来保存文件或目录的各种属性, 包括文件名、文件长度、最后修改时间、是否可读等；文件类还有以下功能：提供获得当前文件的路径名, 判断指定文件是否存在, 获得当前目录中所有文件列表, 创建文件、删除文件、创建目录、删除目录等操作的方法。 示例：课本例10.6 7. 文件过滤器接口FileFilter和FilenameFilter 知识点解析: 文件过滤器接口FileFilter和FilenameFilter用来实现对文件名字符串的过滤。两个接口中都声明accept()方法来实现过滤操作。 示例：课本例10.7 8. 随机文件类RandomAccessFile 知识点解析:随机文件类用于进行随意位置、任意类型的文件访问，并且在文件的读取方式中支持文件的任意读取而不只是顺序读取。 示例：课本例10.8 四、设计题（以下题目1、2题必做，第3题选做） 1. 利用文件字节输入输出流和数据字节输入输出流，将"九九乘法表"写入整数类型文件，并输出显示。 2. 将Java的关键字保存在一个文本文件中，判断一个字符串是否为Java的关键字。 3. 使用文件字节输入/输出流，合并两个指定文件；当文件中的数据已排序时，合并后的数据也要求是已排序的。 第9章输入/输出流与文件操作 9.1 什么是流？流有什么用？面向对象语言为什么需要流？哪些场合需要流？ 答：流是指一组有顺序、有起点和终点的字节集合，是对数据传输的总称或抽象（也就是数据在两个对象之间的传输称为流）。 流的作用就是使数据传输操作独立于相关设备。 在面向对象的程序设计中，数据的传输和流动具有广泛性，可以在内存与外部设备之间传输，还可以从内存到内存，甚至可以从一台计算机通过网络流向另一台计算机等，故面向对象语言采用流机制。 在标准输入/输出、在文件的读/写等操作中都需要流。 9.2 Java提供了哪些流类？各种流类之间的关系是怎样的？什么场合需要使用什么流类？ 答：Java中按照流的方向性，流分为输入流和输出流两大类。按照流中元素的基本类型，流分为字节流和字符流两大类。字节流类按照流的方向分为字节输入流类和字节输出流类，字符流类方向性分为字符输入流类和字符输出流类。以及文件操作类File，随机存取文件类RandomAccessFile. 其中InputStream类是所有字节输入流的根类，OutputStream类是所有字节输出流的根类；Reader类是所有字符输入流的根类，Writer类是所有字符输出流的根类。 9.3 操作系统中文件和目录概念是怎么样的？Java提供了哪些对文件和目录操作的类？程序中对文件和目录能够进行哪些操作？如何操作？ 答：文件是信息的一种组织形式，是存储在外部存储介质上的具有标识名的一组相关的信息集合。目录是文件系统组织和管理文件的基本单位，保存它所管理的每个文件的基本属性信息（称为文件目录项或文件控制块）。 Java直接对文件的顺序存取和随机存取操作，提供了File类记载文件属性信息，对文件读/写操作时以流的形式。RandomAccessFile类以随机存取方式进行文件读/写操作。但在对文件操作过程中还需要使用文件过滤器接口和文件对话框类。在操作系统中，目录也是以文件的形式保存的，称为目录文件。故一个File对象也可以表示一个目录。可以对文件进行读、写、删除、创建等操作，对目录可以读取、创建、删除等操作。应用程序通过调用操作系统提供的系统调用能够对文件及目录进行各种操作。 再打开、保存、复制文件时，需要读/写文件中的数据内容，这些操作由流实现，不同类型的文件需要使用不同的流泪。 9.4 流与文件操作有什么关系？实际应用中将流类与文件操作结合起来能够实现哪些复杂问题？如何实现？ 答：对文件的操作时通过流这个工具进行的。再打开、保存、复制文件时，需要读/写文件中的数据内容，这些操作由流实现，不同类型的文件需要使用不同的流泪。 9.5 什么是输入/输出?什么是标准输入/输出？Java怎样实现标准输入/输出功能？答：数据由外部设备流向内存，这个过程称为输入；数据有内存流向外部设备，这个过程称为输出。 在计算机系统中，标准输入是从键盘等外部输入设备中获得数据，标准输出是向显示器或打印机等外部输出设备发送数据。 Java在https://www.doczj.com/doc/fa1745663.html,ng.System类中声明了3个常量in、out和err用于实现标准输入/输出功能。 9.6 除了标准输入/输出及文件操作之外，还有那些应用中需要使用流？ 第11章数据库管理系统 1. 简述DBMS的基本功能。 解： DBMS用于操纵和管理数据库的大型软件，它对数据库进行统一的管理和控制，以保证数据库的安全性和完整性。拥有以下基本的功能： ●数据库的定义和创建：DBMS提供数据定义语言(DDL)定义和创建数据库模式、外 模式、内模式等数据库对象。 ●数据组织、存储和管理：DBMS要分类组织、存储和管理各种数据，包括数据字 典、用户数据、存取路径等。 ●数据库的操作：DBMS提供数据操纵语言(DML)实现对数据的操作，包括：查询、 插入、删除和更新。 ●数据库的保护功能：DBMS对数据库的保护主要通过四个方面实现：1)数据库的恢 复。2)数据库的并发控制。3)数据完整性控制。4)数据安全性控制。 ●数据库的维护功能：数据库的维护包括数据库的数据载入和转换、数据库的转储和 恢复、数据库的改组以及性能监控等功能。 ●数据库的通信功能以及不断发展的新的数据管理技术。 2. 根据处理对象的不同，DBMS主要分为哪几个层次？ 解： 根据处理对象的不同，数据库管理系统的层次结构由高级到低级依次为 应用层：应用层是DBMS与终端用户和应用程序的界面层，处理各种数据库应用 语言处理层：语言处理层主要是处理数据库语言，如SQL。 数据存取层：数据存取层处理单个元组，将上层集合操作转换成单元组操作。 数据存储层：数据存储层的处理对象是数据页和系统缓冲区，包括缓冲区管理、内外存交换、外存的数据管理等。 3. 试述语言翻译处理层的主要任务。 解： 语言翻译处理层用于处理数据库语言，其任务就是将用户以不同形式提交的数据库语句转换成对RDBMS内存可执行的基本存取模块的调用序列。语言处理层对数据库语言的各类语句进行语法分析、视图转换、安全性检查、完整性检查、查询优化等，通过对下层基本模块的调用，生成可执行代码。 4. 简述数据存取层主要包括的功能子系统及各个子系统的任务。 解： 在实际的DBMS中，数据存取层功能是由多个功能子系统来完成的。它主要包括以下功能子系统。 ● 存储子系统，用于保存数据的存取原语。 ● 事物管理子系统，提供定义和控制事物的操作。 ● 信息控制管理子系统，提供对数据字典中说明信息的读取、增加、修改和删除操作。 ● 排序/合并子系统，根据用户要求输出有序结果、删除重复值、加速关系运算的处 理过程，通常要对元组进行重新排序和合并。 ● 存取路径维护子系统，提供数据执行插入、删除、修改操作时对相应存储路径的维 护。 一. 创建文件 （1）最常用的（获得一个固定路径下的文件对象） File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。 （2）在父目录创建一个名为child的文件对象，child 为文件对象的名字 File chileFile= new File(“D:\\My Documents\\.....”,String child); 或File chileFile= new File(parentFile,String child); 二,常见文件夹属性和方法 （1）createNewFile（）； 该方法的作用是创建指定的文件。该方法只能用于创建文件，不能用于创建文 件夹，且文件路径中包含的文件夹必须存在 File file=new ("D:\\My Document\\text.txt"); file.createNewFile(); 这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保 证D盘下有My Documen这个文件夹） （2）mkdir(); 根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目 录在当前目录下 （3）mkdirs(); 如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。 （4）exists(); 判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）； 判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。 （6）getName();获得文件名称（不带路径） （7）length（）； 得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在 系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0 （8）delete（）; 删除File对象所指定的文件 （9）isFile（）； 判断File对象指向的文件是不是标准文件（就像图片，音乐文件等） 三,文件的属性和方法 1.File.separator 当前操作系统的名称分隔符，等于字符串“\”. 实验八输入输出流类及文件的读写 一、实验目的： 1、掌握标准输入输出（iostream库中标准对象cin、cout）的使用 2、熟悉IO流类成员函数输入输出（cin.get, cin.getline, cin.read; cout.put, cout.write）的使用 3、掌握输出格式（标准控制符、IO流类成员函数、iomanip 头文件中的控制符）控制方法 4、掌握磁盘文件的输入输出方法 二、实验环境： 1、PC计算机一台； 2、Dev-C＋＋开发环境。 三、实验内容: 1、创建一个文件xx.txt，编写程序，统计文件中字符的个数。 2、定义描述职工工资的类Laborage，数据成员为职工号(No)、姓名(Name[8])、应发工资(Ssalary)、社保金(Security)、实发工资(Fsalary)。定义公有成员函数Input()，在Input()函数内输入职工号、姓名、应发工资、社保金，实发工资由公式： Fsalary=Ssalary-Security计算。定义输出职工工资的成员函数Show()。在显示函数Show()中，职工号、姓名的输出域宽为8、 左对齐，其余数据的输出域宽为10、右对齐、保留小数点后两位，输出格式均用预定义格式控制函数设置。在主函数中用Laborage 类定义职工对象数组a[3]。用Input()输入职工工资，用Show()显示每个职工的工资。 五、实验代码及结果（程序运行结果请以截屏图给出）：（1） #include 第十章 输入／输出流 实验六输入输出流与文件 一、实验目的 1．理解数据流的概念 2．理解Java流的层次结构 3．理解文件的概念 二、实验要求 1．掌握字节流的基本使用方法 2．掌握字符流的基本使用方法 3．能够创建、读写、更新文件 三、实验内容 （一）运行以下程序 1.使用标准数据流的应用程序 标准数据流指在字符方式下（如DOS 提示符）程序与系统进行输入输出的方式，键盘和显示器屏幕是标准输入输出设备，数据输入的起点为键盘，数据输出的终点是屏幕，输出的数据可以在屏幕上显示出来。 1．程序功能：将键盘上输入的字符在屏幕上显示出来 2．编写KY10_1.java 程序文件，源代码如下。 class KY10_1{ public static void main(String[] args) throws java.io.IOException { byte buffer[]=new byte[10]; System.out.println("从键盘输入不超过10 个字符，按回车键结束输入："); int count =System.in.read(buffer);//读取输入的字符并存放在缓冲区buffer 中 System.out.println("保存在缓冲区buffer 中元素的个数为："+count); System.out.println("buffer 中各元素的值为："); for (int i=0;iJava 输入输出流及文件读写详解
第9章输入输出流与文件操作
文件流是以外存文件为输入输出对象的数据流
数据库基本操作习题与答案
java输入输出流和文件操作
实验五 输入输出流
第10章-输入输出流
第十二章_数据库技术新发展_1_
第12章数据库的启动与关闭
实验6 输入输出流操作
第9章 输入输出流与文件操作
数据库技术与应用第11、12章 习题答案
javaFile文件操作和文件流的详解(福哥出品)
实验八+输入输出流类及文件的读写
输入输出流
程序在运行时通常要和外部进行交互， 即从外部读取数据或向外部设备发送数据， 这就 是所谓的输入／输出(Input/Output)。 数据可以来自或者发往文件、 内存、 另一个程序或网络。 数据也可有不同的格式，例如可以是各种编码（ASCII 码或 Unicode 码等）的字符串、图像、 声音或对象等等。 Java 语言使用抽象概念——流来描述程序与数据发送或接收者之间的数据 通道。使用输入／输出流，程序员可以方便灵活和安全地实现输入输出功能。
§10.1 输入／输出基本概念
10.1.1 外部设备与文件
我们可以从不同角度对外部设备进行分类。 按照外部设备的工作特性， 我们可将外部设 备分为两类：存储设备和输入／输出设备。 存储设备用于存储信息，包括硬盘、软盘、磁带、光盘等。程序可将数据写入到这些设 备上，也可从这些设备读出数据，数据通常组织为文件形式。这类设备上存储的数据在物理 上往往是按字符块组织的，因而又将它们称为块设备。 输入／输出设备又可分为输入设备和输出设备。 输入设备是计算机用于接受外界信息的 设备，诸如键盘、鼠标、扫描仪等均为输入设备；输出设备是将计算机处理完毕的数据送往 外界的设备，诸如显示器、打印机、绘图仪等均为输出设备。由于这两类设备上的数据往往 是以字符为单位组织的，所以又称它们为字符设备。 计算机程序要与外界进行交互就必须使用相应的机制与输入／输出设备打交道。 程序的 输入是指从输入设备接收数据，程序的输出是指将数据传递给外部设备。 早期的高级程序设计语言对特定的外部设备提供特定的输入／输出操作， 这导致设计出 来的程序代码可移植性很差。后来引入了文件（file）的概念，在程序中不仅可以声明文件 并将文件作为输入／输出的对象， 而且还可以在文件与某个外部设备之间建立关联， 将文件 作为输入设备与输出设备的抽象描述。 目前文件已成为高级程序设计语言输入／输出机制的 基本概念。 一个文件必须有一个由用户命名的唯一名字。 文件可用于存储程序和数据， 还可用于提 高程序的设备无关性， 所谓设备无关性不仅指程序要独立于同类设备的具体台号， 而且还要 独立于设备的类型。 当我们的程序向屏幕或打印机输出时， 不必考虑使用的是哪一种型号的 显示器或打印机。 在操作系统中， 输入／输出设备被视作一种特殊的文件， 这类文件的名字是由操作系统 预先规定好的。例如在 MS-DOS 中显示器被命名为 CON 的文件（控制台终端 console 的缩 写） 、打印机被命名为 PRN 的文件（printer 的缩写） 。这样，程序的输入／输出操作采用了 与文件统一的方式，而不用理会实际的物理设备是什么。
10.1.2 文件的基本概念
Java 语言将文件看作是字节的序列， 即由一个个字节的数据顺序组成。 例如我们要将一 个班全体学生的基本资料存放在一个文件中， 文件中的数据并不是由学生记录组成的， 而是 由一个个字节组成的。 如何将文件中的这些字节组织为记录是由程序完成的， 文件本身并没 有划定任何边界。因而这种文件又称为流式文件（stream file） 。 (1)文本文件与二进制文件 根据文件中数据的组织形式， 可将文件分为文本文件和二进制文件两类。 文本文件存放 的是 ASCII 码（或其他编码的）字符，使用 Windows 操作系统的记事本打开可正确查看其
-1-实验六 输入输出流与文件
相关主题
文本预览