JAVA 网络编程基础

JAVAJAVA网络编程基础网络编程基础

第一部分第一部分 JAVAJAVA 程序设计基础程序设计基础第五章异常处理异常处理第六章 Java的可重用类

第一章第一章计算机语言概述计算机语言概述

第一节第一节程序设计语言第二节第二节语言翻译程序第三节第三节 Java虚拟机与运行环境第四节第四节 Java程序的运行第五节第五节 Java程序的开发、执行流程小结习题

第二章第二章 JavaJava 的开发环境的开发环境第一节第一节 Java的开发环境第二节第二节 JDK的安装、环境配置及使用第三节第三节 JBuilder 6的开发环境小结习题

第三章第三章 JavaJava 语言基础语言基础第一节第一节一个简单的Java程序实例第二节第二节标识符、注释和分隔符第三节第三节变量和常量第四节第四节基本类型第五节第五节运算符及表达式

第六节第六节运算符的优先级第七节第七节数据类型转换第八节第八节语句和复合语句小结习题

第四章第四章 JavaJava 面向对象的程序设计面向对象的程序设计第一节第一节面向对象的理论基础第二节第二节类与对象的基本概念第三节第三节 Java的类第四节第四节继承第五节第五节对象的创建及使用第六节第六节 null , this 和 super

第七节第七节接口第八节第八节包小结习题

第五章第五章 5.1 5.1 异常类的层次 5.2 5.2 throws抛出异常 5.3 5.3 throw抛出异常抛出异常 5.4 5.4 try-catch异常处理

5.55.5 Finally子句5.6 5.6 正确地使用异常小结习题

第五章异常处理第五章异常处理一为什么要引入异常二异常的几个概念 ( 处理机制 ) 三异常处理四小结

为什么要引入异常机制当程序运行的时候，经常会由于各种不可避免的原因而产生错误。一个好的程序应该可以自己处理这些错误，而不是使整个程序全部瘫痪。 Java 把运行中各种可能出现的错误都看作异常并提供了异常处理的能力 (异常处理 )。

异常的几个概念异常机制的过程：抛出异常——捕捉异常 1 当出现了一些错误，方法都会产生一个异常对象，这个异常对象将交由运行系统来处理。此过程就称为抛出 (throwing) 异常。

2 接着，运行系统开始寻找合适的处理方法，来处理这个异常。如果系统找到了一个适合的处理该异常方法，这一过程就叫捕获异常。

包括：系统抛出用户自定义抛出

异常类的结构Object

Throwable

ErrorException

ObjectNon-RuntimeExceptionRuntimeExceptionIOException

异常类常用的方法public Exception()

public Exception(String s): 该参数一般表示该异常对应的错误的描述 public String toString(): 返回描述当前异常对象信息的字符串。public String getMessage(): 返回描述当前异常对象信息的详细信息。public void printStackTrace(): 打印当前异常对象使用堆栈的轨迹。

异常处理机制的语法支持异常处理由 try/catch/[finally] 三个语句组成的：⑴ try 包含可能出现异常的语句块⑵ 一个或多个 catch 块紧随 try{} 块，每个 catch 块通常处理指定类型的异常⑶ finally 引导块紧随 catch 块后，主要用于清理现场（可有可无）注意： finally 块总是执行， catch 块不一定执行格式：

try

{ ......

}catch( ExceptionName1 e )

{ ......}

catch( ExceptionName2 e )

{ ......}

finally

{ ......}

自定义的抛出异常自定义抛出语句 throw 异常类对象；说明：⑴ throw 之后必须接异常类 (Throwable 或其子类 ) 的实例。⑵ 程序会在 throw 语句立即终止，其后的语句不再执行⑶ 抛出语句应在满足一定条件时执行 (如与 if 连用 )⑷ 含有 throw 语句的方法，抛出的异常一般由调用者处理

声明可能生成但没处理的异常指定函数抛出的异常方法内的代码有可能发生异常而又不自己进行处理时，就必须在声明方法时一并指出方法有可能发生的异常，以便该方法的调用者或系统的预设处理方法能够捕获并处理由方法抛出的异常。声明格式：返回类型方法名 ([参数列表 ]) throws 异常类列表 { < 方法体 > } 注意： Error 和 RuntimeException 类及它们的子类一般不需在方法声明中指定 (属 Java 不检查异常）　

小结异常处理把错误集中起来统一处理。程序员只需要说明何处可能出现异常，如何处理即可。

throws 抛出异常和方法说明联系在一起，是针对以下况：调用的方法抛出了异常、检测到了错误并使用 throw语句抛出异常、程序代码有错误从而异常。方法中出现的异常由 catch 语句捕获，进行处理。

try-catch 异常处理机制。当 try 体中发生了一个异常， try-catch 语句就会自动在 try 体后面的各个 catch 语句中，找出与该异常类相匹配的参数，就执行包含这一参数的 catch 语句中的 Java 代码。不论 try 块中是否发生了异常，是否执行过 catch 语句，都要执行 finally 语句，可以说是为异常处理事件提供的一个清理机制。

第六章第六章 JavaJava 的可重用类的可重用类第一节第一节 Java可重用类的结构第二节第二节 Java语言包(Java.lang) 第三节第三节常用容器数据类型第四节第四节输入输出包java.io 小结习题

当程序运行的时候，经常会由于各种不可避免的原因而产生错误。例如除数为零、文件找不到而无法读写等等。 Java 提供的丰富的异常情况处理机制通常叫异常处理。异常处理把 Java 程序各种可能出现的错误都看作异常，集中起来统一处理。程序员只许要说明何处可能出现异常，如何处理即可。

5.1 异常类的层次异常处理的概念

异常在 Java 中也是作为类的实例的形式出现的。 Java中的所有的异常类都是从 Throwable 类派生出来的。 Throwable 类有两个直接子类： java.lang.Error 和 java.lang.Exception 。异常类的层次结构如图5-1所示。 Error 类及其子类主要用来描述一些 Java 运行时刻系统内部的错误或资源枯竭导致的错误。普通的程序不能从这类错误中恢复，也无法抛出这种类型的错误，这类错误出现的几率是很小的。另一个异常类的子类是 Exception 类和它的子类。在编程中错误的处理主要是对这类错误的处理，如除数为零、数组下标越界等。类 Exception 是普通程序可以从中恢复的所有规范了的异常的父类。

5.1 异常类的层次

Exception 类又有两个子类： RuntimeException 和Non_RuntimeException 。 RuntimeException 类处理的错误包括：错误的强制类型转换、数组越界访问、空引用。 RuntimeException 是程序员编写程序不正确所导致的异常，是在 Java 系统运行过程中出现的异常，如除数为零等。由于运行时异常可能会出现在程序的任何地方，而且出现的可能性非常大，因而由程序本身去检测运行异常出现与否，将会使程序的开销过大，所以编译器并不要求程序去说明或捕获运行时异常。 RuntimeException 类的异常的产生是程序员的过失，理论上，程序员经过检查和测试可以查出这类错误。


N0_RuntimeException 类的异常包括：格式不正确的URL、试图为一个不存在的类找到一个代表它的类的对象。 Non_RuntimeException 是指可以由编译器在编译时检测到的、可能会发生在方法执行过程中的异常，如找不到指定名字的类或者界面，不是程序本身的错误，如果这些异常情况没有发生，程序本身仍然是完好的。如果程序不能适当地处理可能会引发运行异常的语句，则程序将不能通过编译器的编译。 Java 提供了两种不同的异常抛出机制： throws抛出异常——间接抛出异常 throw 抛出异常——直接抛出异常


图 5-1 异常类的层次结构

Object

Throwable

ErrorException

ObjectNon-RuntimeExceptionRuntimeExceptionIOException

throws异常说明总是和方法说明出现在一起。这样，方法说明告诉编译器该方法可能会产生哪些异常，从而要求它的调用者必须考虑处理这些异常。带 throws异常说明的方法说明形式如下： … 方法名 (…) [throws 异常类列表 ] { 方法体 } 方法抛出的异常类是 throws子句中指定的异常类或其子类。比如在方法的说明中指明方法可能产生 IOException ，但是实际上可能抛出的异常或许是 EOFException 类的实例，这些异常都是 IOException 的子类。并不是所有可能发生的异常都要在方法的说明中指定，从 Error 类中派生出的异常和从 RuntimeException 类中派生的异常就不用在方法声明中指定。这两类异常属于不检查异常。不检查异常则是那些无法干预的异常。 Java 中的另

5.2 throws 抛出异常

一类异常是检查异常，检查异常是那些在程序中应该处理的异常，程序完全可以避免的异常（比如数组越界错误）。而 throws异常说明必须指定有可能发生的检查异常。在下列情况下 Java 方法抛出异常： (1) 调用的方法抛出了异常； (2) 检测到了错误并使用 throw 语句抛出异常； (3) 程序代码有错误，从而异常，比如数组越界错误。例 5.1 throws抛出一个异常class Test {…… public String getInput() throws IOException； {…… // throws一个异常 }}


例 5.2 throws 多个异常class Animation{ // throws 多个异常 public Image loadImage(String s) throws EOFException, MalformURLException { …… }}


在程序中使用 throw 语句（注意，这里是 throw 而不是 throws ）来抛出异常，该异常可以在该程序中进行捕获、处理，也可以在调用该方法者捕获、处理。 throw 语句的形式为： throw 异常类的实例 ;例 5.3import java.io.IOException;public class ThrowException { public static void main(String args[]) { try { String s=getInput(); //getInput() throw 抛出异常 System.out.println(s); }

5.3 throw 抛出异常

catch(IOException e) // 捕获异常 {System.out.println(e.getMessage()); } } static String getInput() throws IOException{ // getInput() 方法抛出异常 ,因为在它的方法体中调用的 //read方法抛出异常 ,并且该方法体本身使用 throw 抛出异常 char[] buffer =new char[20]; int counter = 0; boolean flag =true; while(flag) { buffer[counter] =(char)System.in.read();


if(buffer[counter]=='\n') flag = false; counter++; if(counter>=20){ IOException ae =new IOException("buffer is full"); //构造异常实例 throw ae; //抛出异常类的实例 } } return new String(buffer); }}


上面的例中说明了一个方法 getInput() ，它用来获取从键盘输入的字符，并以字符串对象的形式返回。并且从键盘输入的字符数不能多于 20个，否则就抛出一个 IOException 异常。由于在方法 getInput() 中，可能会产生 IOException 异常，所以在方法的说明中必须指明方法可能抛出异常： static String getInput() throws IOException 在方法 getInput() 中，可能产生异常的地方有两处，一是 Java 的 InputStream类的 read() 方法。 InputStream类的 read() 方法如下所示： public abstract int read() throws IOException 但是在方法 getInput() 中，我们并没有捕获和处理这个异常： buffer[counter]= (char)System.in.read()；


另一个可能产生异常的地方是方法中的 while循环： while(flag) {buffer[counter] = (char)System.in.read(); if(buffer[counter]= =‘\n’) flag = false； counter++ ； if(counter>=20) {IOException ae =new IOException(“buffer is full”) ； throw ae; } }


在这个循环中，如果输入的字符数大于 20，就会抛出一个 IOException 异常（这里只是作为抛出异常的一个示范，实际上这并不是 IOException 异常）。而在方法main 中将捕获这个异常，并打印出异常的信息。如果没有异常发生，就打印输入得到的字符串。可以看出，抛出异常有这样三步：（ 1）确定异常类；（ 2）创建异常类的实例；（ 3）抛出异常。


利用 try-catch 语句可以说明抛出异常的部位，同时又说明捕获、处理的办法。 try…catch 语句形式如下： try { 语句系列 } catch（异常类 1 变量名 1） { catch 处理 } …… catch（异常类 n 变量名 n） { catch 处理 } [finally 语句 ]其中 : try 之后的复合语句说明抛出异常的部位，该部位含有抛出异常的语句，如调用抛出异常的方法等 ; catch( 异常类变量名 ) 是按抛出的异常类进行捕获 ; catch 处理是对捕获的异常作相应的处理；如果有 finally部分 ,其后的语句是最后必然要执行的语句。

5.4 try-catch 异常处理

例 5.4 try-catch 异常处理：import java.io.*;public class Try_catch{public static void main (String args[]) {FileInputStream fis=null; try { fis=new FileInputStream(“c:/filename.txt”); } // FileInputStream 方法抛出异常，所以位于 try 体内 catch(FileNotFoundException e) // 捕获 FileNotFoundException 异常 {System.out.println("catchexception"+e.getMessage());}


try { int c=fis.read(); // 调用的 read() 方法抛出异常 } catch(IOException e) // 捕获 IOException 异常 { System.out.println("catchexception:"+e.getMessage()); } }}

上述 try-catch 语也可改写成：


try //有多个语句抛出异常 { fis=new FileInputStream(“c:/fileName.txt”)； //filename.txt指要读入的文件名 int c=fis.read () ； //读字节整数 } catch (FileNotFoundException e) { //捕获 FileNotFoundException 异常 System.out.println(“catchexception:”+e.getMessage())； } catch(IOException e) //捕获 IOException 异常 {System.out.println(“catchexception:”+e.getMessage()); } //在这里用 e.getMessage()得到有关异常的信息


当 catch 前面的 try块中发生了一个异常， try-catch 语句就会自动在 try块后面的各个 catch 块中，找出与该异常类相匹配的参数。当参数符合以下三个条件之一时，就认为这个参数与产生的异常相匹配： (1) 参数与产生的异常的属于一个类； (2) 参数是产生的异常的父类； (3) 参数是一个接口时，产生的异常实现了这一接口。当产生的异常找到了第一个与之相匹配的参数时，就执行包含这一参数的 catch 语句中的 Java 代码，执行完 catch语句后，程序恢复执行，但不会回到异常发生处理继续执行，而是执行 try-catch 结构后面的代码。


finally语句可以说是为异常处理事件提供的一个清理机制，一般是用来关闭文件或释放其他的系统资源，作为 try-catch-finally结构的一部分，可以没有 finally语句，如果存在 finally语句，不论 try块中是否发生了异常，是否执行过 catch 语句，都要执行 finally语句。带有 finally 子句的 try-catch-finally语句的形式如下： try { … } //…是正常执行的代码 , 可能产生异常 catch ( 异常类 1 e1) { … } //…是异常类 1 的处理代码 catch ( 异常类 2 e2) { … } //…是异常类 1 的处理代码 …… catch ( 异常类 n en) { … } //…是异常类 1 的处理代码 finally { … } //… 是执行清除工作的语句

5.5 finally 子句

5.5 finally 子句带有 finally子句的 try-catch-finally语句无论在 try块中是否产生异常，也不管产生的异常是否会被捕获， finally中的语句最终都会被执行。具体的执行过程如下： (1) try块中的语句没有产生异常。在这种情况下， Java首先执行 try块中的所有的语句，然后执行 finally子句中的代码，最后执行 try…catch..finally块后面的语句； (2) try块中的语句产生了异常，而且此异常在方法内被捕获。在这种情况下， Java首先执行 try块中的语句，直到产生异常处，然后跳过此 try块中剩下的语句，执行捕获此异常的 catch 子句的处理代码；然后执行 finally子句中的代码； (3) 如果 catch 子句中没有重新抛出异常，那么 Java将执行 try…catch…finally块后面的语句。如果在 catch 子句又重新

抛出了异常，那么 Java将这个异常抛出给方法的调用者； (4) try块中产生了异常，而此异常在方法内没有被捕获。在这种情况下， Java将执行 try块中的代码直到产生异常，然后跳过 try块中的代码而转去执行 finally子句中的代码，最后将异常抛出给方法的调用者。例 5.5 打开一个文件流，读入两个字符串，转化为整数，并求其和。import java.io.* ；class sum{public static void main(String args[]) { DataInputStream fis=null；

5.5 finally 字句

try { fis=new DataInputStream(new InputStream(“myfile.txt”)); // 建立读入“myfile.txt”文件的输入流 String stra=fis.readln(); //读入一个字符串 int a=Integer.parseInt(stra); //把该字符串转化为整数 String strb=fis.readln(); int b=Integer.parseInt(strb); int c=a+b； System.out.println(c.toString()); // 输出 c } catch(FileNotFoundexception e) { System.out.printIn(e.toString()); } catch(IOException e) { System.out.println(e.toString()); } catch(NumberFormatException e) { System.out.println(e.toString()); }

5.5 finally 字句

finally { if(fis= =null) {System.out.println(“DateInputStream not open!”) } // 输入流没有打开 else { fis.close() ； // 关闭输入流 System.out.println(“Close DalaInStream!”); } } }} 在这个程序中，输入流的关闭是放在 finally块中统一完成的。如果不使用 finally语句，程序就要考虑在发生不同异常的情况下，文件是否能关闭。考虑到在不同的可能出现的运行情况下，程序会从不同的地方退出 try/catch 结构，为了知道哪些地方要加上关闭的语句，

5.5 finally 字句

就不得不分析在所有可能出现的情况下，文件输入流能否关闭 : (1) 文件正常运行，没有异常发生时，执行 try块中全部语句，因而 try块中要有关闭语句； (2) 产生文件没有找到异常，则输入流没有建立，也就不必关闭； (3) 产生读入字符引起的 IO异常，进入相应的 catch 语句，需要在该 catch 块中关闭； (4) 产生字符串转化为整数时的类型不匹配异常，进入相应的 catch 语句，需要在该 catch 块中关闭。根据这一分析，程序可能就要写成如下的形式：//不用 finally语句的 sum.java import java.io.*;class sum{public static void main(String args[]) //方法main() 没抛出异常

5.5 finally 字句

{DataInputStream fis=null; try { //try体可能有抛出的异常或程序错 fis=new DataInputStream(new FileInputStream(“myfile.txt”))； // 建立读入“myfile.txt”文件的输入流 String stra=fis.readLine(); //读入一个字符串 , 可能抛出异常 int a=Integer.parseInt(stra)； //把该字符串转化为整数 String strb=fis.readLine();//读入一个字符串 , 可能抛出异常 int b =Integer.parseInt(strb); //把该字符串转化为整数 int c=a+b； System.out.println(c.toString()); // 输出 c fis.close()； } catch(FileNotFoundException e) { System.out.println(e.toString()); }

5.5 finally 字句

catch(IOException e) {System.out.println(e.toString()); fis.close()； } catch(NumberFormatException e) {System.out.println(e.toString())； fis.close()； } }} 很明显，在程序中有三处地方要执行 fis.close() 语句，使程序代码重复，而且今后进行修改时也容易出错。所以用finally语句的一个好处，就是把方法中所有清除状态和关闭文件的语句放在一起，不但避免了代码重复，更减少了出现遗漏语句的现象，对程序将来的修改也较为集中和方便。

5.5 finally 字句

由于异常使用起来非常方便，以至于在很多情况下可能会滥用异常。但是，使用异常处理会降低程序运行的速度，如果在程序中过多地使用异常处理，程序的执行速度会显著地降低。这里给出几点建议，来帮助掌握好使用异常处理的尺度。 (1) 在可以使用简单的测试就能完成的检查中，不要使用异常来代替它。例如： if (ins!=null) //使用 ins引用对象 { … } (2) 不要过细地使用异常。最好不要到处使用异常，更不要在循环体内使用异常处理 , 可以将它包裹在循环体外面 . (3) 不要捕获了一个异常而又不对它做任何的处理。如下例所示：

5.6 正确地使用异常

try { …… // 正常执行的代码 } catch(Exception e) { } (4) 将异常保留给方法的调用者并非不好的做法。对于有些异常，将其交给方法的调用者去处理是一种更好的处理办法。

5.6 正确地使用异常

异常处理把 Java 程序各种可能出现的错误都看作异常，集中起来统一处理。程序员只需要说明何处理可能的出现异常，如何处理即可。 throws 抛出异常和方法说明联系在一起，是针对以下情况：调用的方法抛出了异常、检测到了错误并使用 throw 语句抛出异常、程序代码有错误从而异常。 try-catch 异常处理机制。当 try 体中发生了一个异常， try-catch 语句就会自动在 try 体后面的各个 catch 语句中，找出与该异常类相匹配的参数，就执行包含这一参数的 catch语句中的 java 代码，执行完 catch 语句后，程序恢复执行，但不会回到异常发生处理继续执行，而是执行 try-catch 结构后面的代码。 finally 语句为异常处理事件提供的一个清理机制。

小结

1. 什么是异常？简述 Java 的异常处理机制。2. 系统定义的异常与用户自定义的异常有何不同？如何使用这两类异常？3. 编写从键盘读入 10个字符放入一个字符数组，并在屏幕上显示它们的程序，程序中处理数组越界异常。

习题

6.1 java 可重用类的结构

Java 有一系列功能强大的可重用类 , 功能相关的可重用类组织成包。可重用类的继承层次和包的组织呈树型结构。

6.1 java 可重用类的结构Java 可重用类本书中主要涉及的有 :

• 语言包 java.lang(lang意为 language) • 输入 / 输出包 java.io 、• 实用程序包 java.util(util意为 utility)• 小应用程序包 java.applet• 图形用户接口包 java.swing• 网络包 java.net 前三种包称为基础包，后三种包称为应用包。

图图 6-1 6-1 给出了 Jave 资源的层次结构

Java Java.langJava.net

Java.ioJava.util

Java.applet

Java.swing

…..

…..

…..

…..…..

图 6-1 Java 工具包层次图

Java.lang.Math

Java.lang.System

Java.io.File

Object 类 public boolean equals(Object obj) 比较对象是否相等 protected Object clone()用来生成当前对象的拷贝 ,被克隆的对象必须支持 Cloneable public final Class getClass()用来生成当前对象所属类的信息

6.2 Java6.2 Java 语言包（语言包（ Java.langJava.lang ）） Java 语言的核心部分是 java. lang, 它定义了 Java 中的大多数基本的类。

下面介绍其中的类： object Class—— 为运行时搜集的信息 Math—— 提供数学常数及各种函数。

System—— 提供对操作系统的访问，包括默认的 I/O 流环境变量、自动垃圾收集、系统时间和系统属性； Runtime—— 提供了操作系统的访问：使用 java.lang.System 可以更容易地访问大多数 Runtime 方法；唯一的例外是exec 方法，它开始一个新进程。Thread—— 和 java.lang.Runnable 接口协同作用提供 Java 中的多线程的支持。Throwable—— 它是 Java 中所有异常 (Exception) 的基类

6.2 Java6.2 Java 语言包（语言包（ Java.langJava.lang ））

6.2 Java6.2 Java 语言包（语言包（ Java.langJava.lang ）） 6.2.1 6.2.1 字符串类 6.2.3 6.2.3 数据类型类数据类型类 6.2.3 Math6.2.3 Math 类类

数据类型类数据类型类基本数据类型类Boolean boolean

Character char

Double double

Float float

Integer integer

Long long

6.2.1 6.2.1 字符串类字符串类

1. 1. String类 2. 2. StringBuffer类

java.lang 提供了两种字符串类： String 类 StringBuffer 类

String s=”Hello!”； public String();public String(StringBuffer buffer)public String(String ss)； public String(char value[])； public String(char value[],int offset,int count)；public String(byte ascii[] ,int offset, int count)public String(byte ascii[])

1.1. StringString 类类

String 类提供的几种常用的字符串创建方法：String 类可创建一个对象，用于代表一个字符串 ( 不变的字符串 ) ，并定义了类似查找，比较和连接字符的操作。

方法：

字符串的比较：public boolean equals(String s)public boolean equalsIgnoreCase(String s) 与字符串 s 比较相等否 ,相等返回 true; 反之 ,返回 false public int compareTo(Object obj)public int compareTo(String s)public int compareToIgnoreCase(String s) 与字符串 s 比较字典顺序 , 相等返回 0; 当前串大于 s返回 1; 当前串小于 s返回 -1

1. String1. String 类类 String 类提供了丰富的字符串操作方法，主要有：

public boolean regionMatches (int toffset,String Other,int offset,int len) ；判断两个字符串的指定区域的字符子串是否相同判断字符串的前缀和后缀public boolean startsWith(String prefix) 如当前串以串 prefix 开始则返回 true; 否则返回 falsepublic boolean endsWith(String suffix) 如当前串以串 suffix结尾则返回 true; 否则返回 false

1. String1. String 类类

•求字符串的长度 public int length()•字符串的连接 public String concat(String str) （注：使用“ +”运算符更方便）•字符串的截取： public char charAt(int index): 截取一个 public String substring(int beginindex,int endindex)•字符串的查找public int indexOf(String str)在当前字符串中寻找与 str匹配的子串，返回首次匹配的起始下标值，无匹配返回 -1。 public int lastIndexOf(String str)public int lastIndexOf(String str,int fromIndex)•其它数据类型转换成字符串 public static String valueof( 数据类型 data) •大小写转换 public String toLowertCase()public String toUpperCase()•拷贝到数组 public char[] toCharArray()

1. String1. String 类类

注意 : String 类的所有方法都不会改变String 类对象本身的值！

StringBuffer 类实现一种动态可变的字符串。 2. StringBuffer2. StringBuffer 类类

StringBuffer 类提供三种创建方法： public StringBuffer()； public StringBuffer(int length)； public StringBuffer(String str)；

StringBuffer 类提供的方法主要用于把输入数据转换为 String 类。

2. StringBuffer2. StringBuffer 类类

StringBuffer 的主要方法：public int length() 返回缓冲区的当前字符数。public int capacity() 返回缓冲区的最大容量。public synchronized StringBuffer append(type variable) public synchronized StringBuffer append(Char(char ch)) public synchronized StringBuffer insert(int offset,type variable) 把 variable转换为字符串 , 然后插入到当前串由 offset指定的位置

例 6.1 利用 StringBuffer 类将键盘输入的数据建立一个字符串实例。 import java.io.*; public class StringBufferToString {public static void main(String args[]) {char ch; try

2 . StringBuffer2 . StringBuffer 类类public synchronized StringBuffer insert(int offset,char ch) 把字符 ch插入到当前串由 offset指定的位置 public synchronized String toString() 把 StringBuffer 转换为字符串 String

{int length =20; // 置 StringBuffer 的大小为 20(书上有错 ) StringBuffer strb=new StringBuffer(length); while ((ch=System.in.read())!=’\n’) { strb.append(ch) } String str=strb.toString(); // (书上这二句放后面 , 错 ) System.out.println(str); } catch (IOException e) { } } }

2. StringBuffer2. StringBuffer 类类

1 1 一维数组 2 2 多维数组

数组是相同类型的数据元素按顺序组成的一种复合数据类型元素在数组中的相对位置由下标来指明。数组中的每个元素通过数组名加下标进行引用。在 Java 中，数组是一个类，所以要用 new建立实例才可用。数组分为一维数组和多维数组。

6.2.2 数组

1) 一维数组的说明与构造其格式如下：类型数组名 [ ] ；（或类型 [ ] 数组名；）数组名 = new 类型 [数组长度 ] ；

1. 一维数组

2) 数组的初始化数组的初始化方式有两种：一、在说明数组的同时进行初始化 ( 称为静态初始化 ) ；二、仅用 new创建数组，让它取缺省值，到以后再为元素赋值 ( 称为动态初始化 ) 。

1. 一维数组

例如： int a[ ]={1,2,3,4,5}; // 静态初始化 int list[ ] = new int[3]; //动态初始化

1. 一维数组

3) 数组元素的使用声明了一个数组，并用 new 语句为它分配了内存空间后，就可以在程序中像使用任何变量一样来使用数组元素，数组元素的标识方式为：数组名 [下标 ] 下标数据类型只能为 byte,short,int, 而不能为 long 。

1. 一维数组

Java.util.ArraysJava.util.ArraysSystemSystem封装了一些对数组整体进行操作的方法封装了一些对数组整体进行操作的方法

1. 一维数组

多维数组是通过对一维数组的嵌套声明来实现的。 1) 二维数组的说明与创建二维数组说明的格式为：类型数组名 [ ] [ ] ；（或类型 [ ][ ] 数组名；）此时还没有为数组元素分配内存空间，还需要用 new关键字来创建数组，然后才可以使用该数组的每个元素。

2 . 多维数组

对二维数组来说，分配内存空间有下面几种方法。（ 1）直接为每一维分配空间，如： int a[ ] [ ] = new int[2] [3] ；

a[0][0] a[0][1] a[0][2]

a[1][0] a[1][1] a[1][2]

（ 2）从最高维开始，分别为每一维分配空间，如：

2. 多维数组

b[0][0]

b[0][1]

b[0][2]

b[1][0]

b[1][1]

b[1][2]

b[1][3]

b[1][4]

int b[ ][ ] = new int[2] [ ] ；b[0] = new int[3] ；b[1] = new int[5] ；下图为该数组的示意图。

2. 多维数组这说明， Java 中并不要求构成多维数组的各个维数都相同。但在声明中第一维的维数一定要声明

2）二维数组元素的初始化二维数组元素的初始化同一维数组一样有两种方式： (1) 在说明数组的同时进行初始化。 (2) 仅用 new创建数组，让它取缺省值，到以后再为元素赋值 ( 称为动态初始化 ) 。

2. 多维数组

例： int a[ ][ ] = { {1}, {2,3}, {4,5,6} } ； 3）二维数组元素的引用对二维数组中每个元素，其引用方式为：数组名 [下标 1] [下标 2] 其中下标 1 、下标 2 为非负的整型常数或表达式，如：a[2][3] 、 cc[i+2][j*3 ](i,j 为整型 ) 等。同样，每一维的下标取值都从 0 开始。

2. 多维数组

1 1 三角函数 2 2 乘方 3 3 舍入 4 4 其他

java.lang.Math 类是标准的数学类 ,封装了一些数学函数和常量。它的所有方法和变量也都是静态的。

6.2.3 Math 类

下面的三个方法接受一个 double 类型的且以弧度为单位的角度值 ,并返回相应的运算结果 ,返回类型均为 double型。（ 1） sin(double a) 返回弧度 a 的 sin值（ 2） cos(double a) 返回弧度 a 的 cos 值（ 3） tan(double a) 返回弧度 a 的 tan值

1. 三角函数

下面的三个方法是反三角函数，返回类型均为 double 型。（ 1） asin(double r) 返回 sin值为 r 的弧度（ 2） acos(double r) 返回 cos 值为 r 的弧度（ 3） atan(double r) 返回 tan值为 r 的弧度

例 : Math.sin(3.1416/6) 将返回 0.5000010603626028 例 : Math.cos(3.1416/4) 将返回 0.7071054825112363 例 : Math.asin(0.5) 将返回 0.5235987755982989 ( 即 π/6 )

（ 1） pow(double x, double y) 返回 x 的 y次方。（ 2） exp(double x) 返回 ex（ 3） log(double x) 返回 x 的自然对数。（ 4） sqrt(double x) 返回 x 的平方根。

（返回类型均为 double 型）

2. 乘方

例 : Math.pow (2.0, 3) 将返回 8.0 例 : Math.sqrt (16) 将返回 4.0 注意 :使用数学函数时，别忘加 “Math.”，即不要把“ Math.sqrt(16) ” 写成 “ sqrt(16) ”

（ 1） ceil(double a) 返回大于或等于 a 的最小整数值。（ 2） floor(double a) 返回小于或等于 a 的最大整数值。（ 3） rint(double a) 返回四舍五入后的整数值。（上面三个方法的返回类型均为 double 型）（ 4） round(float a) 返回四舍五入后的整数值 , 返回类型为 int 型。（ 5） round(double a) 返回四舍五入后的整数值 , 返回类型为 long 型。

3. 舍入

例： Math.ceil(2.1) 将返回 3.0 Math.rint(2.1) 将返回 2.0 Math.ceil(-2.1) 将返回 -2.0 Math.round(2.1) 将返回 2 Math.floor(2.1) 将返回 2.0 Math.round(2.5) 将返回 3 Math.floor(-2.1) 将返回 -3.0

（ 1） abs(a) 返回 a 的绝对值 a 可以是 int 、 long 、 float 、 double 型，返回类型与 a 的类型相同。（ 2）max(a,b) 返回 a 和 b 的最大值（ 3）min(a,b) 返回 a 和 b 的最小值 (2) 、 (3) 中的 a 、 b 类型相同 , 可以是 int 、 long 、 float 、 double 型，返回类型与 a 、 b 的类型相同。（ 4） random() 返回一个 0.0到 1.0 之间的随机数，返回类型为 double 型

4. 其它

6.3.1 6.3.1 数组数组 6.3.2 6.3.2 向量类及其使用 6.3.3 6.3.3 哈希表类及其应用 6.3.4 6.3.4 栈类 6.3.5 6.3.5 日期时间类（）日期时间类（）

java.util 包提供了许多实用的类，如：日期、向量、哈希表、锁和堆栈等。6.3 常用容器数据类型

java.util 包由一些实用类组成的，有些类还是 Java 语言所不可缺少的。 java.util 包的大致层次结构如图6-4所示

6.3.1 java.util 包的构成

java.util.*图 6-4 java.util 包层次结构

说明： Dictionary是抽象类， Enumeration 和 Observer 是接口，其余属于普通类； Hashtable 除继承Dictionary类外，还是 java.lang 类库中 Cloneable 的一个实现； BitSet 和 Vector 除继承了类 Object外，同时也是 java.lang.Cloneable 的实现 ; BitSet 是最终类，不能用以创建子类。

日期时间类的实例可通过如下几种方法予以创建： 1) public Date() 这个构造方法将把当前日期和时间保存于所创建的 Date 实例。 2) public Date(int year, int month, int date)

6.3.2 日期时间类日期时间类是一个相对简单、但使用频繁的类，它提供了独立于具体系统的日期 /时间的表示形式。

3) public Date(int year, int month, int date, int hours, int minutes) 4) public Date(int year, int month, int date, int hours, int minutes,int seconds)下面是日期时间类的一些方法 :

6.3.2 日期时间类

public int getYear(); 返回当前日期中的年份 public int getMonth()；返回当前日期中的月份 public int getDate(); 返回当前日期中的日 (0-31) public int getDay()；确认某天是星期几 public int getHours()；返回当前日期中的小时数 public int getMinutes()；返回当前日期中的分钟数 public int getSeconds()；返回当前日期中的秒数 public boolean before(Date when) ；对日期实例所代表的时间和 when 进行比较 .若比when早 ,返回 true; 否则返回 false public boolean after(Date when); 对日期实例所代表的时间和 when 进行比较。若比 when晚 ,返回 true;否则返回false public boolean equal(Object obj); 比较两个日期对象 ,若相等则返回 true;否则返回 false


public String toString(); 返回当前日期参数的字符串表示形式。注意 :不同主机系统的日期表示形式不尽相同


日期时间类的使用非常简单 , 只需要创建一个类实例不带任何参数 , 即可以生成一代表当前日期的类。如下所示： Date today = new Date( ); System.out.println(today.toString( )); 或者也可用一更为简单的方式： System.out.println(today); 后一种方式中， println将自动调用 toString 方法，因而无需显式调用。

6.3.3 6.3.3 向量类向量类 ((VectorVector)) 及其使用及其使用 1. 1. 向量和数组的异同向量和数组的异同 2. 2. 向量类的构造方法、属性和方法 4. 4. 向量维护 5. 5. 对象查找

向量 (Vector) 和数组存在许多相似之处，它们都是类，均可用以保存列表。数组只能保存固定大小的列表，列表中元素的类型必须一致，必须一次申请所有的存储单元。如果事先无法确定列表内究竟要存放多少对象， Java 的数组就无能为力了。向量却提供了一种与 “动态数组” 相近的概念，它可以动态地增加它的列表长度，列表中元素的类型还可以不一致，但必须都是对象。另外，向量提供了比数组更多的方法。尽管向量与数组相比有许多重要的优点，但它也有一些不足之处，其中之一是它不能直接存储简单数据类型。

1. 向量和数组的异同

下列场合较适合于使用向量： 1) 如果需要频繁进行对象的插入和删除工作，或者需要处理的对象数目不定； 2) 列表成员全部都是对象( 类型可不一致 ) ，或者可以用对象方便地表示； 3) 需要很快确定列表内是否存在某一特定对象，并且希望很快了解到对象的存放位置。

下列场合较适合于使用数组： 1) 所需处理的对象类型一致，数目固定或大致可以确定，尽管具体对象经常发生变化； 2) 所需处理的是简单数据类型。

由于向量只能存储对象，故如果需要把简单数据类型保存到向量，必须使用 Java 的数据类型类，因此，有些场合下使用数组要比使用向量方便一些。

1. 向量和数组的异同

向量类共有 3种形式的构造方法，如下所示： Vector(int capacity, int capacityIncrement) ；用指定的向量容量及其增量参数，创建一个空向量 Vector(int capacity) ；用给定的向量容量参数 , 创建一空向量 Vector( ) ；创建一空向量

2. 向量类的构造方法、属性和方法

向量容量——向量中可存放的元素个数容量增量——规定了每当向量元素个数达到极限时，需一次性扩充的向量容量大小

向量容量、容量增量

“容量增量”参数说明如果容量增量参数为 0，则每次向量容量都将增加一倍大小。如果忽略这两个参数，这时 Java 将自动为维护向量的使用，包括必要时向量的增容等。向量类提供了如下 3个属性变量： protected int capacityIncrement ；当向量大小不足时，所用的增量大小protected int elementCount ；向量的元素个数protected Object elementData[ ] ；向量成员数据所用的缓冲


public final synchronized void copyInto(Object anArray[]); 把向量元素拷贝到指定数组 public final synchronized void trimToSize(); 把向量容量调整到正好等于向量元素个数以压缩向量的存储空间。这样，随后的插入操作将导致重新申请内存空间public final synchronized void setSize(int newSize); 设置向量大小。如果向量被缩小 ,多余的元素将被截断 ;如果被放大 , 新增的向量元素将置为 nullpublic final int capacity() 返回向量容量public final int size() 返回向量的元素个数，注意和 capacity( )之间的区别

下面是其中一些主要的方法：2. 向量类的构造方法、属性和方法

public final Boolean isEmpty() 若向量不包括任何元素，返回 true;否则返回 falsepublic final synchronized Enumeration elements() 返回向量元素所对应的枚举值，以便随后用 Enumeration( ) 方法获取该向量元素public final boolean contains (Object elem) 若向量中包括了对象 elem ，返回 true ；否则返回 falsepublic final int indexOf (Object elem) 返回向量下标；若对象不存在，返回 -1public final synchronized int indexOf (Object elem, int index) 从指定位置（ index ）开始搜索向量，返回对象所对应的向量下标值。若未找到对象，返回 -1public final int lastIndexOf (Object elem) 从向量末尾向前搜索向量，返回对象的下标值


public final synchronized int lastIndexOf(Object elem,int index) 从指定位置开始向前搜索向量，返回给定对象的下标值 public final synchronized Object elementAt(int index) 返回指定下标处的对象若下标值非法，抛出一 ArrayIndexOutOfBoundsException 异常情况public final synchronized Object fistElement() 返回向量的第一个元素。若向量为空，抛出一个 NoSuchElementException 异常情况 public final synchronized Object lastElement() 返回向量的最后一个元素。若向量为空，抛出一 NoSuchElementException 异常情况


public final synchronized void setElementAt(Object obj, int index) 把给定对象存放到给定下标处 ,该下标处的原有对象丢失 .若下标值非法 ,抛出异常情况 ArrayIndexOutOfBoundsExceptionpublic final synchronized void removeElementAt(int index) 删除给定下标处的向量元素，后面元素前移一个位置。若下标值非法，抛出异常情况 ArrayIndexOutOfBoundsException public final synchronized void insertElementAt(Object obj, int index) 把给定对象插入到指定下标处 . 该下标之后的元素后移一个位置 .若下标值非法 ,抛出异常 ArrayIndexOutOfBoundsException


public final synchronized void addElement (Object obj) 把给定对象增加到向量末尾 public final synchronized boolean removeElement (Object obj ) 从向量中删除指定对象。若给定对象在向量中有多个，则只删除其第一个实例。若向量中没有这个对象，返回 false public final synchronized void removeAllElements ( ) 删除向量中的所有对象。这时向量将变成空向量 public final synchronized String toString ( )把向量转换成字符串。请注意：这个方法实际上覆盖了 Object 类中的 toString （）方法


和数组一样，向量需要声明并实例化才可使用，其内存空间通过 new操作符分配的。例如： Vector theVector = new Vector()；一个向量在被创建后，将自行在系统内部维护一个专用数组，并在必要时对数组大小进行动态调整。比方说，如果插入一个向量元素时，向量的空间需求超过了这个内部数组的大小，向量将向系统申请一些新的内存空间。

3 . 建立向量实例

例： Vector theVector = new Vector( ) ； for( int i = 0; i<10; i++ ) { Integer newInteger = new Integer(i); theVector.addElement( newInteger ); }

4. 向量维护增： addElement( ) 方法把对象插入到向量末尾。

向量可用以保存任何类型的对象，同一个向量实例甚至还可以保存多种不同类型的对象。

下面的例子是给向量交错插入一些浮点数和字符串。 Vector theVector = new Vector( ); String testString; testString = “pai”; theVector.addElement( testString ); Float testFloat = new Float( 3.14 ); theVector.addElement( testFloat ); testString = “Faill”; theVector.addElement(testString); testFloat = new Float( 59 ); // 注 : 书是多了’ Float’ theVector.addElement( testFloat ); 向量： {“pai”, 3.14, “Faill”, 59}

增加向量元素的另一方式是通过 insertElementAt( )方法。该方法把对象插入到向量的给定位置。

4. 增，改：

删：这时有 3个方法可用： removeFlement() ；删除指定对象 removeElementAt() ；删除给定位置处的对象 removeAllElement() ；删除所有向量成员前两个方法在删除一个元素之后，后面的对象将前移一个位置。对于前面例子中介绍的向量，下面语句将删除其中的 3.14和 59，而不是3.14和“ Faill”。 Float deleteFloat = new Float(3.14); theVector.removeElement(deleteFloat); theVector.removeElementAt(2);

4. 向量维护

对象查找中最常遇见的情况是给定一个下标值，希望由此确定该下标处的对象。这时可使用 elementAt( ) 方法。5. 5. 对象查找对象查找

对应前面的程序，下面这行程序返回一对象引用，该引用指向向量成员” pai” ： Object tempObj = theVector.elementAt(0); 当需要确定向量中是否包括了某一确定的对象时 , 可使用 contains( ) 方法。 public final Boolean contains(Object elem);这个方法返回一布尔值。若向量包含了对象 elem,返回 true ，否则返回 false 。

用下标来访问数组元素 , 这是使用数组的最有效方法。向量成员也可用下标进行访问 , 方法有： elementAt() 返回给定下标处的对象 indexOf() 从给定下标处往后搜索向量中是否包含指定的的对象 lastIndexOf() 从给定下标处往前搜索向量中是否包含指定的的对象

利用下标进行访问5. 5. 对象查找对象查找

indexOf() 和 lastIndexOf() 方法的完整声明形式如下 : public final synchronized int indexOf (Object elem, int start_index ) public final synchronized int lastIndexOf (Object elem, int start_index ) 这两个方法均用以从给定下标开始搜索向量，确定向量中是否包含了指定的对象。如果是，则返回该对象的下标值，否则返回 -1 。

5. 5. 对象查找对象查找

1. 1. 哈希表类的构造方法、属性变量和成员方法 2. 2. 哈希表的使用

•哈希表是一种支持对表中元素进行快速检索的线性表•特征：表中元素的平均检索时间与表中的元素个数无关。•哈希表是利用“码值 (关键字 )—元素”形式的存储列表的元素

6.3.4 6.3.4 哈希表哈希表 ((Hashtable)) 类及其应用类及其应用

1) 构造方法哈希表 (Hashtable) 类共有三种形式的构造方法 : public Hashtable(int initialCapacity,float loadFactor); 参数 initialCapacity 给定哈希表创建初始可容纳的元素数量 ,loadFactor 为装载因子 , 取值 0.0到 1.0 之间 public Hashtable(int initialCapacity); 　　　参数 initialCapacity 给定哈希表创建初始可容纳的元素数， loadFactor 为缺省值 public Hashtable();　　　参数 initialCapacity和 loadFactor) 为均为缺省值

1. 1. 哈希表的构造方法、属性变量和成员方法哈希表的构造方法、属性变量和成员方法

2)属性变量哈希表类没有定义属性变量

哈希表类定义的主要方法如下： public int size() 返回哈希表大小 ( 即表中元素个数 ) public boolean isEmpty() 确认哈希表是否为空 public synchronized Enumeration keys() 返回哈希表内关键字枚举值 public synchronized Enumeration elememnts() 返回哈希表内元素的一个枚举值对象，随后用 Emumeration 类方法顺序获取对象 public synchronized boolean contains(Object value) 确认哈希表内是否包括了给定的对象 ,与 containKey() 类似public synchronized boolean containsKey(Object key) 确认哈希表内是否包括了给定的关键字 ( 注意 , 书是有错 !) public synchronized Object get(Object key) 获取对应关键字的对象，如不存在返回 null

1. 1. 哈希表的构造方法、属性变量和成员方法哈希表的构造方法、属性变量和成员方法3) 成员方法

protected void rehash() 再哈希 ,扩充哈希表使之可以保存更多的元素。当哈希表达到饱和时 ,系统将自动调用此方法public synchronized Object put(Object key,Object value)用给定的关键字把对象保存到哈希表中。随后该对象即可通过同样的关键字由 get 方法获取。这里的关键字和元素均不可为空public synchronized Object remove(Object key) 从哈希表中删除与给定关键字相对应的对象 ,如该对象不存在返回 nullpublic synchronized void clear()从哈希表中删除所有对象，使其为空public synchronized String toString() 把哈希表内容转换为一字符串 ,此方法复盖了 Object 类的 toString()方法

1. 1. 哈希表的构造方法、属性变量和成员方法哈希表的构造方法、属性变量和成员方法

例如： HashTable hash_1=new HashTable();

2.2. 哈希表的使用哈希表的使用哈希表创建与 Java 中其它对象一样需使用 new操作。

　为了把对象保存到哈希表，必须为每一个对象分配一关键字。关键字可以为任意对象，但必须实现了 hashCode() 和 equals() 方法。 Java提供的类几乎都提供了这两个方法。建好哈希表后，增操作： hash_1.put(“one”,new Integer(1)); hash_1.put(“two”,new Integer(2)); hash_1.put(“three”,new Integer(3));

2.2. 哈希表的使用哈希表的使用删操作： remove() 方法。　　 hash_1.remove(“two”); 　　如指定的关键字不存在， remove() 返回 null 。查找操作：get() 和 containsKey() 可以查找关键字对应的对象，不存在返回 null 。例如： Integer n=(Integer) hash_1.get(“three”); if (n!=null) System.out.println(“three=”+n); 如果查找的关键字不存在， get 返回 null 。

栈类定义的主要方法如下： public Stack(); 栈类构造方法 public Object push (Object item) 把对象压入栈 public Object pop () 从栈顶弹出一个对象 public Object peek() 读栈顶一个对象，但不弹出 public boolean empty() 测试栈是否为空 , 是则返回 True, 否则返回 False

6.3.5 6.3.5 栈类栈类 Java 语言规范中，栈类是向量类的子类，它满足 FIFO(先进后出 ) 的要求。

6.4 输入输出包 (java.io)

6.4.16.4.1 流（stream） 6.4.2 6.4.2 基本输入/输出流 6.4.3 6.4.3 File类 6.4.4 6.4.4 字符流文件 6.4.5 6.4.5 字节流文件

6.4.6 6.4.6 过滤流6.4.7 6.4.7 文件拷贝实例

6.4.1 6.4.1 流流 (stream)(stream)

数据源数据宿程序

“流”可以被理解为一条“管道”。这条“管道”有两个端口：一端与数据源（当输入数据时）或数据宿（当输出数据时）相连，另一端与程序相连。


流及有关的流类

只要在程序和数据源 / 数据宿之间建立了流，用户就不需要再关心数据来自何方或送向何处，程序中输入 /输出操作的复杂性就大大降低了。所有输入 /输出操作都转换为对流的操作。


图6-7 为 java 字节流输入输出接口、类的继承图。

6.4.1 6.4.1 流流 (stream)(stream)流的分类

• 根据“管道”里流动的数据的类型 , 流被分为字符流 (Character Streams) 和字节流 (Byte Streams) ，• 根据流的建立方式和工作原理，流分为节点流 (Node Streams) 与过滤流 (Filter Streams) ，节点流是直接建立在输入、输出媒体之上的，而过滤流必须以某一个节点流作为流的来源

•根据流中数据传输的方向，流被分为输入流和输出流。

6.4.2 6.4.2 基本输入输出流基本输入输出流 1 1 InputStream类 2 2 OutputStream类 3 3 System.in和System.out对象

public int read() throws IOException 从流中读取一个字节并将该字节作为整数返回 ,若没有数据则返回 -1 public int read(byte b[]) throws IOException 从流中读取多个字节放到 b 中 , 返回实际读取到的字节数 public int read(byte b[],int off,int len) throws IOException 从流中读取最多 len 字节的数据 , 放到数组 b 的下标 off开始的单元中，返回读取到的字节数 (注 : 书上解释不正确 )public long skip(long n) throws IOException 跳过流中指定的字节数

1.1. InputStreamInputStream 类类 InputStream类表示基本输入流，是字节流，它定义了一套所有输入流都需要用的方法： read 的重载

byte b[]=new byte[3];System.in.read(b);for (int i=0;i<3;i++)System.out.print(b[i]+" ");System.out.println();String s=new String(b);System.out.print(s);

read方法使用例： System.out.println( System.in.read() ); System.out.println( (int)System.in.read() ); System.out.println( (byte)System.in.read() ); System.out.println( (char)System.in.read() );

1.1. InputStreamInputStream 类类输入 aaaa,输出 : 97 97 97 a

输入 aaa,输出 : 97 97 97 aaa

public int available() throws IOException 返回当前流中可用的字节数public void close() throws IOException 关闭当前流对象public synchronized void mark(int readlimit) 在流中标记一个位置public synchronized void reset() throws IOExeeption 返回流中标记过的位置public boolean markSupported() 返回一个流是否支持标记和复位操作的布尔值

1. InputStream1. InputStream 类类

程序在运行到 System.in.read() 时 ,等待用户输入且直到用户输入一个回车键为止。

1. InputStream1. InputStream 类类

注意： InputStream类操作的是字节数据而不是字符。 ASCII码中字符和字节数据对应的都是 8位数据，而在Unicode 字符集中，字符都被设置为 16位数据，这样 , 利用 InputStream类来接收键盘字符将接收不到字符的高位信息！

当程序中调用 InputStream进行请求时，所调用的方法就处于等待状态，例如： try { int byte=System.in.read(); } catch(IOException e) { System.out.println(e.toString()); }

与 InputStream类相对应的输出流是 OutputStream,它具有所有输出流类的基本功能，同 InputStream类相似，它具有以下相应的方法：public abstract void write(int b) throws IOException 向流中写一个字节public void write(byte b[]) throws IOException 向流中写入一个字节数组public void write(byte b[],int off,int len) throws IOException 从数组 b 的第 off个位置开始写入 len长度的数据 public void flush() throws IOException 清空流并强制将缓冲区中的所有数据写入到流中 public void close() throws IOException 关闭流对象

2. OutputStream2. OutputStream 类类

例 6.2 用 System.out 和 System.in 对象处理输入和输出class MyClass{ public static void main(String[]args) { byte buffer[]=new byte[20]; System.out.println(“请在下面输入一行字符：” ); try { System.in.read(buffer,0,20); } //System.in.read抛出异常

3. System.in3. System.in 和和 System.outSystem.out 对象对象为了支持标准的输入输出设备， Java 定义了两个流的对象，静态成员： System.in 从键盘中读入数据 System.out 将数据输出到显示屏。它们是类变量 ( 对象 ), 可直接使用。

catch(Exception e) { //捕获异常并处理 System.out.println (“ 读取输入字符出错，错误信息为： +e.toString()); } System.out.println(“您刚才输入的一行字符为 :”); String inputStr=new String(buffer,0); System.out.println(inputStr); }} 上面程序在执行到 System.in 语句时 , 等待用户输入字符 , 然后将输入的字符重新在显示器中输出。在接收用户输入数据时可能出错，因此还对 System.in 捕获异常，若出现异常则在显示器中将异常信息显示出来。例如 , 将 try块内的语句改成“System.in.read(buffer,0,30);”,就将发生异常 .

3. System.in3. System.in 和和 System.outSystem.out 对象对象

文件 (file) 是存储在辅助存储器中的一组相关信息的集合 ,它可以存放程序、文档、图片、声音或视频信息等。为了便于对文件管理 , 系统允许用户给文件设置或取消有关的文件属性 , 如只读属性、隐藏属性、存档属性、系统属性。目录 (directory) 是一种特殊的文件，用以存放普通文件或其他的目录。磁盘格式化时，系统自动地为其创建一个目录 (称为根目录 ) 。用户可以根据需要在根目录中创建低一级的目录 (称为子目录 ) ，子目录中还可以再创建下一级的子目录，从而形成树型目录结构，目录也可以设置相应的属性。路径 (path) 是从盘符经过各级子目录到文件的目录序列。由于文件可以在不同的磁盘、不同的目录中，所以在存取文件时，必须指定文件的存放位置。

6.4.3 File6.4.3 File 类类文件目录路径

文件的存放位置通过路径来描述，路径的表示格式为：盘符 \目录名 \…\文件名，比如在 C盘根目录下的子目录WINDOW下子目录 JAVA中的文件myfile.java ，应表示为 C:\WINDOW\JAVA\myfile.java 其中， C:为驱动器名，表示 C盘，而 \WINDOW\JAVA\表示myfile.java 所存储的位置，其中第一个“ \”表示根目录，其余的“ \”为各子目录之间、最后一级子目录与文件名之间的分隔符。在一个树型目录结构中，任一时刻，可以指定一个当前工作或操作的子目录，称其为当前目录（又叫缺省目录）。凡从根目录开始的路径叫做绝对路径，应以“ \”开头；凡不从根目录开始而从当前目录开始的路径叫相对路径，应从当前目录的下级目录开始写起。

6.4.3 File6.4.3 File 类类缺省目录相对路径绝对路径

例如，假使上述文件myfile.java完整的文件标识是 C:\WINDOW\JAVA\myfile.java ，如果当前磁盘是 C盘 ,可写成 \WINDOW\JAVA\myfile.java；如果当前目录是 C:\WINDOW，可写成 JAVA\myfile.java；如果当前目录是C:\WINDOW\JAVA，可改写成myfile.java 。 java.io 包中定义了一个 File 类来专门处理文件，并获取文件的有关信息。 Java 语言中通过 File 类来建立与磁盘文件的联系。 File 类用来获取或设置文件或目录的属性，但不支持从文件读取数据或者往文件里写数据。文件是许多程序的基本数据源和数据宿，是保存永久数据和共享信息的媒体。在 Java 中，目录也被当作文件，可以用 list 方法列出目录中的文件名。

6.4.3 File6.4.3 File 类类

创建文件对象有三种构造方法，这里引用三个例子分别创建了三个文件对象： file1 、 file2 、 file3 ，它们都指向文件“ c ：\cgi-bin\demo.java”。 File 类的功能十分强大，它可以访问指定文件的所有属性，包括文件名称、文件长度、文件的最后修改时间等，同时还可以利用 File 类来建立文件对象、删除文件和改变文件名称等。


File 类具有下面三种构造函数： File (String path); File (String path,String name); File (String dir,String name);其中参数如下所示： String path——指定的路径； String name—— 执行的文件名； String dir—— 执行的目录；

public String getName() 得到文件名public String getPath() 返回文件路径 public String getAbsolutePath() 返回文件绝对路径public String getCanonicalPath() throws IOException 返回文件的规范路径public String getParent() 返回文件的父目录public boolean exists() 判断文件是否存在public boolean canWrite() 判断文件是否可写public boolean canRead() 判断文件是否可读public boolean isFile() 判断对象是否是文件public boolean isDirectory() 判断对象是否是目录

6.4.3 File6.4.3 File 类类File 类的有关方法：

public native boolean isAbsolute() 如果文件名为绝对名则返回真public long lastModified() 返回文件最后修改日期public long length() 返回文件长度public boolean mkdir() 创建目录public boolean rename To(File dest) 重命名文件public boolean mkdirs() 创建目录及子目录public String[] list() 列出目录下的所有文件和目录public String[] list(FilenameFilter filter) 列出目录下的指定文件public boolean delete() 删除文件对象public int hashCode() 为文件创建散列代码public boolean equals(Object obj) 判断是否同对象 obj 相等public String toString() 返回文件对象的字符串描述


从上面方法中可以看出， File 类不仅仅是对现有目录路径、文件和文件组的一个表示，它还可以利用 File 对象直接新建一个文件，甚至创建一个完整的目录路径（如果它还不存在的话）；同时我们还可以利用该对象了解文件（文件夹）的属性（包括长度、上一次修改日期、读 /写属性等），检查一个 File 对象到底是一个文件还是目录，以及删除一个文件对象等操作。如果 File 对象是一个目录，可以调用其 list 方法列出 File 对象中包含的完整列表（包含 File 对象的文件夹和文件），若要对这个文件列表作出某种选择，就需要使用一个“目录过滤器”（也是一种“文件过滤器”），该类的作用就是按一定条件选择 File 对象。


例 . 文件过滤器//源程序清单 6.3import java.io.*;public interface FilenameFilter // 文件过滤器接口 { boolean accept(File dir,String name); } //只有一个抽象方法 ,无方法体public class DirFilter implements FilenameFilter { //DirFilter 实现上述接口来对文件过滤 String extn; //文件过滤要求，文件名包含 extn public DirFilter(String extn) //构造方法 { this.extn=extn; }


public boolean accept(File dir,String name) {boolean isAccept; String f=(new File(dir,name)).getName(); if(f.indexOf(extn)==-1) //文件名不包含 extn isAccept=false; else //文件名包含 extn isAccept=true; return isAccept; }} 下面的例 6.4利用上述过滤器找出当前目录下面指定类型（ *.java）的文件。


//源程序清单 6.4import java.io.*;public class DirList { public static void main(String[] args) { try { File file=new File(“.“); //当前路径文件对象 String[] list=file.list(new DirFilter(“*.java”)); for(int i=0;i＜ list.length;i++) System.out.println(list[i]); } catch(Exception e) { System.out.println(e.toString()); } }}


1 1 文件输出流（文件输出流（ FileWriterFileWriter）） 2 2 文件输入流（文件输入流（ FileReaderFileReader））

上节介绍了如何创建一个文件，但是我们更需要了解如何往文件里写数据或读出文件中的内容。文件的读写是通过文件输入流、文件输出流来实现的。按数据交换的单位不同，文件流可分为字符流、字节流两种，这一节中介绍以字符为单位进行文件访问，以字节为单位的方式在下一节介绍，读写的方式都是顺序方式。

6.4.4 6.4.4 字符流文件字符流文件

FileWriter 类可以在一指定的文件上建立一个文件输出流，也可以建立一个文件同时实例化为文件输出流。流提供了将数据写到文件中的方法。如果用 FileWrite 来打开一个只读文件会产生 IOExcption 异常。 FileWriter 类有两种构造方法：构造方法一 : File f=new File(“d:\\t1.txt”)； // 建立文件 FileWriter f1=new FileWriter(f); // 建立文件输出流构造方法二 : (建立文件同时实例化为文件输出流 ) FileWriter f2=new FileWriter(“d:\\t1.txt”)；第一种方法是先建立一个文件对象 f，然后再建立一个输入

1. 1. 文件输出流文件输出流 (FileWriter)(FileWriter)

1. 1. 文件输出流文件输出流 (FileWriter)(FileWriter)

注意：写完后一定要关闭输出流，数据才真正地写到了文件中！

(1) write(char c) 将一个字符写到文件的末尾 (2) write(char b[ ]) 将一个字符数组写到文件的末尾 (3) close() 关闭输出流

流 f1 ，并使输入流 f1 和文件 f相连接。这种情况下，可以通过对象 f对该文件作进一步的分析 , 比如 , 显示文件的属性、大小等。第二种方法就是将第一种方法的二步合成一步，相对来说更方便一些，但不能做文件分析等其它工作。 FileWriter 类的最重要的方法是 write() 与 close() ：

例 . 在 d盘上建立一个名为myfile.txt 的文件，并写入两串字符。

1. 1. 文件输出流文件输出流

import java.io.*; public class FileOutput{public static void main(String[]args)throws Exception {File f = new File("d:\\myfiel.txt"); FileWriter f1 = new FileWriter(f); f1.write("abcdefghij"); f1.write("xyz"); f1.close(); }}

FileReader 类可以在一指定的文件上实例化一个文件输入流， FileReader 类流提供了从文件中读取一个字符或者一组字符方法。 FileReader 类的构造方法都有可能出现 FileNotFoundExcption 异常。构造方法一： File f=new File(“d:\\t1.txt”); FileReader f1=new FileReader(f); 构造方法二： FileReader f2=new FileReader(“d:\\t1.txt”); 这两种建立输入流的方法与前面建立输出流的两种方法意义完全类似。

2. 2. 文件输入流文件输入流 (FileReader)(FileReader)

2. 2. 文件输入流文件输入流 (FileReader)(FileReader)

(1) read( ) 读一字符，返回读入的字符的整型表示 (2) read(char b[ ]) 读入字符放到字符数组 b 中并返回实际读入的字符数。如果所定义的字符数组容量小于获得的字符数，则运行时将产生一个 IOException 例外情况。 (3) read(char b[ ],int off,int len) 读入 len 个字符放到数组 b 下标 off开始的位置中，并返回实际读入的字符数 (4) close() 关闭输入流

FileReader 类的最重要的方法是 read() 与 close() ：

例 . 将d盘上名为myfile.txt 的文件的内容输出到屏幕。2. 2. 文件输入流文件输入流

import java.io.*; public class FileInput{public static void main(String[]args)throws Exception {File f = new File("d:\\myfiel.txt"); FileReader f1 = new FileReader(f); char a[]=new char[(int)f.length()]; f1.read(a); System.out.println(a); f1.close(); }}

要建立 ( 或打开 ) 一个文件并对它进行输入、输出，需要如下几步：

(1) 用 File 类建立 ( 或打开 ) 一个文件； (2) 用 FileWriter(FileReader) 类建立输出 (输入 )流；

(3) 调用 write(read) 进行输出 (输入 ) ； (4) 关闭输出 (输入 )流。

字符文件输入字符文件输入 // 输出方法小结：输出方法小结：

1 1 FileInputStream 2 2 FileOutputStream

平常所使用的文件中，有很多是二进制文件，它们以字节作为数据处理单位。对这些文件就要使用字节流来读写了，其实字符文件也可以用字节流来进行读写。 FileInputStream 和 FileOutputStream分别完成字节流文件的读写。

6.4.5 6.4.5 字节流文件字节流文件

int available() 返回可读入的字节数void close() 关闭输入流，并释放任何与该流有关的资源protected void finalize() 当读到无用信息时，关闭该流FileDescriptor getFD() 返回与该流有关的文件描述符（即文件的完整路径）int read() 从输入流中读取一个字节的数据int read(byte[]b) 将数据读入到一个字节数组中int read(byte[]b,int off,int len) 读入 len 个字节数据放到数组 b 的 off开始的位置中long skip(long n) 跳过输入流上的 n 个字节

1. FileInputStream1. FileInputStream

FileInputStream类方法：

void close() 关闭输出流，并释放任何该流有关的资源protected void finalize() 当写到无用信息时，关闭该流File Descriptor getFD () 返回与该流有关的文件描述符（即文件的完整路径）void write(int b) 将一个字节数据写到输出流中void write(byte[ ]b) 将字节数组中的数据写到输出流中long skip(long n) 跳过输出流上的 n 个字节

2. FileOutputStream2. FileOutputStream

FileOutputStream类方法：

过滤流必须建立在节点流之上，对节点流中的数据进行某些加工、处理，并提供一些友好的方法供用户进行输入、输出操作以及流控制。例如 ,BufferedInputStream可以对任何种类的输入流进行带缓冲区的封装以达到性能的改善（可减少程序 I/O 操作次数，提高程序执行效率）。 Jave利用过滤流可以在读 /写数据的同时对数据进行处理。使用过滤流时要注意：必须将过滤流和某个输入流或输出流 ( 节点流 )连接。而在程序设计中 , 连接是通过在过滤流的构造方法中指定入口参数——节点流来实现的。如： FileInputStream in=new FileInputStream(“text”); BufferedInputStream bufin=new BufferedInputStream(in);实现了过滤流 bufin 和文件输入流 in连接。

6.4.6 6.4.6 过滤流过滤流

6.4.6 6.4.6 过滤流过滤流

1. BufferedInputStream

2. BufferedOutputStream

3. DataInputStream和DataOutputStream

4. ObjectInputStream和ObjectOutputStream

对 I/O进行缓冲是一种常见的性能优化方法。 Jave 的BufferedInputStream类可以对任何的 InputStream流进行带缓冲的封装以达到性能的改善。该类在已定义输入流上再定一个具有缓冲的输入流，可以从此流中成批地读取字符而不会每次都引起直接对数据源的读操作。数据输入时，首先被放入缓冲区，随后的读操作就是对缓冲区中的内容进行访问。

1. BufferedInputStream1. BufferedInputStream

该类有两个构造方法： 1） public BufferedInputStream(InputStream in); 2） public BufferedInputStream(InputStream in,int size);

两种构造方法都有是为某种输入流 in 创建一个缓冲流1. BufferedInputStream1. BufferedInputStream

创建的缓冲大小为缺省值（ 32bytes）方法一方法二

用户指定缓冲区大小对方法二，在性能优化时，通常都把 size 的值设定为内存页大小或 I/O块大小的整数倍。在 I/O 量不大时，该类所起作用不是很明显，但当程序 I/O 量很大，且对程序效率要求很高时，使用该类就能大大提高程序的效率。

对输入流进行缓冲可以实现部分字符重复使用。除了 InputStream中常用的 read和 skip 方法 , BufferedInputStream还支持mark和 reset 方法。注意mark 只能严格限制在建立的缓冲区内。

BufferedOutputStream类在已定义节点输出流上再定义一具有缓冲功能的输出流。用户可以向流中写字符而不会每次都引起直接对数据宿的写操作，只有在缓冲区已满或清空流（flush）时，数据才输出到数据宿上。在 Java 中使用输出缓冲是为了提高性能。

2. BufferedOutputStream2. BufferedOutputStream

该类有两个构造方法：1） public BufferedOutputStream(OutputStream out);2） public BufferedInOutputStream(OutputStream out, int size);

DataInputStream用来从一种已定义的节点输入流中读取 Jave基本数据类型的数据，如布尔型数、整型数、浮点数等，然后再生成一个数据输入流。 DataOutputStream用来将 Jave基本数据类型数据写到一个数据输出流中。这两个类都是在某节点流上再定义一个数据输入 (输出 )流，通过它们，用户可以更方便地按照Jave 原始数据类型来读 ( 写 ) 数据。

3. DataInputStream3. DataInputStream 和和 DataOutputStreamDataOutputStream

1） pubilc DataInputStream(InputStream in); 创建一新的 DataInputStream,该流从输入流 in 读取数据 2） pubilc DataOutputStream(OutputStream out); 在输出流 out上创建一个新的 DataOutputStream,使 DataOutputStream的输出数据能够输出到输出流 out中


构造方法：

例如，建立基于标准输入的输入流的语句可如下： DataInputStream In=new DataInputStream(System.in);

readBoolean() 、 writeBoolean() 读写布尔型数据readByte() 、 writeByte() 读写字节数据 readChar() 、 writeChar() 读写字符数据readLine() 、 writeLine() 读写整行数据


成员方法：

例如，要从键盘输入一行字符，语句可如下： DataInputStream In=new DataInputStream(System.in); String stra=In.readLine();

例 . 建立基于标准输入的过滤流并进行输入3. DataInputStream3. DataInputStream 和和 DataOutputStreamDataOutputStream

import java.io.*; public class DataInput{public static void main(String[]args)throws Exception { int a; double b,c; String str; DataInputStream In=new DataInputStream(System.in); // 建立基于标准输入的过滤流 str=In.readLine(); //读入一个字符串 a=Integer.parseInt(str); //把字符串转化为整数 str=In.readLine(); //读入一个字符串 b=Double.parseDouble(str); //把字符串转化为实数 c=a+b; System.out.println(c); }}

ObjectInputStream和 ObjectOutputStream是针对对象的输入输出。它的使用通过下面的例子来介绍。例 6.5 把 Hashtable 中存放的信息输出到磁盘文件中，并再从中读进 Hashtable. packege ObjectIO;import java.io.*;import java.util.Hashtable;public class ObjectIOClass { public static void main(String args[]) throws Exception {Hashtable ht=new Hashtable(); // 建立一个 Hashtable 对象

4. ObjectInputStream4. ObjectInputStream 和和 ObjectOutputStreamObjectOutputStream

DataInputStream dis=new DataInputStream(System.in); // 建立 DataInputStream对象，并且与标准输入对象连接 String st_no=dis.readLine();//从标准输入读一行存入 st_no String st_rec=dis.readLine();//从标准输入读一行存入 st_rec ht.put(st_no,st_rec); //st_no 作关键字 ,st_rec 为 Hashtable保存的对象 , 存入 ht System.out.println(ht); String st_no1=dis.readLine();//从标准输入读一行存入 st_no1 if (ht.containsKey(st_no1)) //如 Hashtable 对象中有关键字 st_no1, 输出对应的对象 System.out.println(ht.get(st_no1)); else System.out.println("error");


ObjectReadWrite my_object=new ObjectReadWrite(); // 建立文件对象 my_object.write(ht); //如 ht 对象输出到输出源 my_object.read(); //从输入源读入对象 }}public class ObjectReadWrite {static File object_file=new File("d:\\","data");public static void write(Hashtable ht ) { try{ // 建 FileOutputStream对象 ,并与文件对象 object_file连接 FileOutputStream fos=new FileOutputStream(object_file); // 建立 ObjectOutputStream对象 ,并与文件对象 fos 连接


ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(ht); //Hashtable 对象内容写入输出文件中 //o1.flush(); oos.close(); } catch(Exception e){ }; } public static void read() { //从对象输入文件中读对象 try { // 建 ObjectOutputStream对象 ,并与文件对象 object_file连接


ObjectInputStream ois=new ObjectInputStream ( new FileInputStream(object_file )); Hashtable ht1=(Hashtable)ois.readObject(); //从输入源读入对象 System.out.println(ht1); //标准输出 ht1 } catch(Exception e){ e.printStackTrace(); } }}


1 1 创建项目并设计主界面 2 2 获取、浏览文件 3 3 文件拷贝

下面将通过一个文件或文件夹拷贝的实例来说明文件读写的过程。例 6.5 用户在主窗口的源文件栏中输入或点击“浏览”按钮，在弹出的对话框中选择需要拷贝的源文件或文件夹，再在目标文件栏中选择目标文件或文件夹（允许不存在，系统将自动创建）。点击“复制”按钮进行拷贝，同时在右面的列表框中列出当前正在拷贝的文件名。应用程序执行界面如图 6-7所示。下面将具体分步实现这个过程。

6.4.7 6.4.7 文件拷贝实例文件拷贝实例

打开 Jbuilder ，选择菜单“ File→New…”，在新建向导中分别创建工程 coptyFile.jpr 和主窗体类MainFrame.java ，并进入该窗口的 design视图，加入如图 6-5所示的各个组件，在 design视图中双击四个按钮产生它们的点击事件。//源程序清单 6.5-1package CopyFile;import java.awt.*;import java.awt.event.*;import borland.jbcl.layout.*;import borland.jblcl.control.*;public class MainFrame extends Frame { TextField textFieldl= new TextField();Button button1 =new Button();Label labe11 =new Label();

1. 1. 创建项目并设计主界面创建项目并设计主界面

Label labe12 =new Label();TextField textField2 =new TextField();Button button2= new Button();Button button3= new Button();Button button4= new Button();Label labe13 =new Label();Panel Pane11 =new Panel(); PaneLayout paneLayout1=new PaneLayout();PaneLayout paneLayout2=new PaneLayout();GroupBox groupBox1=new PaneLayout();List list1 =new List();PaneLayout paneLayout3=new PaneLayout();public MainFrame() {try{


jbInit();}catch(Exception e) {e.printStackTrace();}} private void jbInit() throws Exception { this.setSize(new Dimension(454,154));this.setTitle（″拷贝文件″）；this.setBackground(new Color(192,192,192);button.setLabel(″ 浏览″… )；button1.addActionListener(new MainFrane_button1_actionAdapter(this));


// 按钮的监听器接口类//MainFrane_button1_actionAdapter 由 Jbuild生成labell.setAlignment(2);labell.setText(″源文件：″ )；labell.setAlignment(2);labell2.setText(″ 目的文件″ )；button2.setLabel(″复制″ )； button2.addActionListener(new MainFrame_button2_actionAdapter(this)); // 按钮的监听器接口类 //MainFrane_button2_actionAdapter 由 Jbuild生成 button3.setLabel(″退出″ )；button4.addAactionListener(new MainFrame_button4_actionAdapter(this));


// 按钮的监听器接口类MainFrane_button4_actionAdapter 由 Jbuild生成 button3.addAactionListener(new MainFrame_button3_actionAdapter(this)); // 按钮的监听器接口类MainFrane_button3_actionAdapter 由 Jbuild生成 this.setLayout(paneLayout1);this.add(panel.new PaneConstraints(“panell”,”panell”,PaneConstraints.ROOT,0,5f); panel1.add(groupBox1,new PanConstraints (“groupBox1”,”groupBox1”,PaneConstraints.ROOT,1.of)); groupBox1.add(list1. new PaneConstraints(“listl”, “listl”,PaneConstraints.ROOT, I.of));


this.add(labell,new PanConstraints (“lable3”, “panell”,PaneConstraints.LEET,0.6300448f); this.add(labell. new PaneConstraints(“labell,“labell3”, PaneConstraints,BOTTOM,0.68589747f) this.add(label2,new PaneConstraints(“label2”, “labell”,PaneConstraints,BOTTOM,0.6730769f));this.add(textField,new PaneConstraints(“textField”, “labell”,PaneConstraints.RIGHT,0.76868325f));this.add(button1,new PaneConstraints(“button2”, “label2”,PaneConstraints,BOTTOM,0.57142854f)); this.add(button4,new PaneConstraints(“textField2”, “label2”,PaneConstraints.RIGHT,0.7686325f)); this.add(button4,new PaneConstraints(“button4”,“


textField2”,PaneConstraints.RIGHT,0.3442623f)); this.add(button3.new PaneConstrains(“button3”, “button2”,PaneConstraints.RIGHT,0.4798851f)); } public static void main(String[] args) { Main Frame frame=new MainFrame();frame.setLocation(200,200);frame.setSize(450,150);frame.show(); }void buttonl_actionPewrformed(ActionEvent e) {}


void button2_actionPerformed(ActionEvent e) { }void button3_actionPerformed(ActionEvent e) { }void button4_actionPerformed(ActionEvent e) { }} 上面程序所生成的四个按钮的监听器接口类由 Jbuilder将其添加到MainFrame.java 类的后面。


例 6.6 源程序清单第 2 部分class MainFrame_buttonl_actionAdapter implements java.awt.event.ActionListener{MainFrame adapter;

MainFrame_buttonl_actionAdapter(MainFrame adaptee){ this.adaptee=adaptee; } MainFrame_butto1_actionAdapter(MainFrame adaptee) {this.adaptee=adaptee; }class MainFrame_button2_actionAdapter implements java.awt.event.ActionListener {MainFrame adaptee; MainFrame_butto2_actionAdapter(MainFrame adaptee) {this.adaptee=adaptee; } public void actionPerformed(ActionEvent e) {adaptee.button2_actionPerformed(e); }}


class MainFrame_button3_actionAdapter implements java.awt.event.AactionListener{ MainFrame adaptee; MainFrame_button3_actionAdapter(MainFrame adaptee) { this.adaptee=adaptee; } public void actionPerformed(ActionEvent e) { adaptee.button3_actionPerformed(e); }}


class MainFrame_button4_actionAdapter implements java.awt.event.ActionListener { MainFrame adaptee; MainFrame_button4_actionAdapter(MainFrame adaptee) { this.adaptee =adaptee; } public void actionPerformed(ActionEvent e) { adaptee.button4_actionPerformed(e); }}


我们可以调用系统的 Filer 组件来实现对系统文件夹的选取。Filer 组件只作为一个对话框来显示打开或保存一个文件，用户可以通过对话框选择一个文件来打开或者是保存，而该组件用来打开或保存一个文件可以通过设置其mode属性来决定 .

2. 获取浏览文件

构造函数有四种方式：public Filer() 直接实例化一个对象 ,其它的属性以后再进行设置；public Filer(java.awt.Frame frame) 创建一个以 frame 为父窗体的对象；public Filer(java.awt.Frame frame,String title) 创建一个以 frame 为父窗口，以 title 为标题的对象；public Filer(java.awt.Frame.String title,int mode) 创建一个以 frame 为父窗口，以 title 为标题，类型为mode的对象，mode 有两种取值，即： Filer.load—— 打开一个文件 Filer.save——保存一个文件

实例化Filer 对象后，可以通过调用其适当的方法来得到其需要打开或保存的文件目录 .2. 获取浏览文件

Filer具有很多方法可以实现对 Filer 组件的控制：public String getDirectory() 返回选择后的文件目录public void setDirectory(java.lang.String dir) 设置文件目录public String getFile() 返回选定后的文件名public void setFile(java.lang.String file) 设置文件名public Frame getFrame() 得到父窗体对象public void setFrame(java.awt.Frame frame) 设置父窗体对象

在MainFram类中添加两个 Filer 组件，并实现两个浏览按钮，将用户选择的打开（源）文件和保存（目的）文件路径显示在文本框中，实例化 Filer 组件，具体代码如下所示：Filer filer1=new Filer(this,this,”选择源文件” ,Filer.load);Filer filer2=new Filer(this,this,”选择目的文件” ,Filer.save);

2. 获取浏览文件public int getMode(int m) 设置打开保存方式public String getTITLE() 得到标题public void setTitle(java.lang.String title) 设置标题public boolean isVisible() 返回是否可见 public void setVisible(boolean visible)设置是否可见public void show() 显示组件

//源代码清单 6-5-2 import java.awt.*;import java.awt.event.*;import borland.jbcl.layout.*;import borland.jbcl.control.*;import java.io.*;import java.util.*;public class MainFrame extends Frame{TextField textField1 =new TextField(); Button button1=new Button(); Label labe11=new Label();

2. 获取浏览文件同时添加两个按钮的点击事件 , 最后得到MainFrame类。（粗体为所添加的代码）

Label labe12=new Label();TextField textField2=new TextField();Button button2 =new Button();Button button3 =new Button();Filer filer1 =new Filer(this,this,″ 选择源文件″， Filer.LOAD);Filer filer2 =new Filer(this,this,″ 选择目的文件″， Filer.SAVE); Button button4= new Button();Label labe13 =new Label();Panel pane11 =new Panel();PaneLayout paneLayout1=new PaneLayout();PaneLayout paneLayout2=new PaneLayout();GroupBox groupBox1=new GroupBox();


List list1=new List(); PaneLayout paneLayout3=new PaneLayout();Public MainFrame() {try {jbInit();}catch(Exception e) {e.printStackTrace();}}private void jbInit() throws Exception {this.setSize(new Dimension(454,154));this.setBackground(new Color(192,192,192));button1.setLabel(″ 浏览″．．．″ )；


button1.addActionListener( new MainFrame_button1_actionAdapter(this));button1.addActionListener( new MainFrame_button1_actionAdapter(this));labell.setAlignmetnt(2);labell.setText(″源文件：″ )； labe12.setAlignement(2); label2.setText(″ 目的文件″ )；button2.setLabel(″复制″ )；button3.addActionListener( new MainFrame_button2_actionAdapter(this));button3.setLabel(″退出″ )；button3.addAactionListener( new MainFrame_button3_actionAdapter(this));


button3.setLabel(″ 浏览″．．． )；button4.addActionListerer( new MainFrame_button3_actionAdapter(this));label3.setText(“请输入或选择源文件 ( 夹 ) 和目标文件(夹 ):”)；groupBox1.setLayout(panLayout3);groupBox1.setLablel(″下载队列″ )；this.setLayout(paneLayoutl); this.add(pane11,new PaneConstraints (“panell”,“panell”,PaneConstraints.ROOT,0.51)); pane11.add(groupBox1.new PaneConstraints (“groupBox1”,“groupBox1”,PaneConstraints.ROOT,1.0f));groupBox1.add(list1,new PaneConstraints (“list1”,”list1”,PaneConstraints.ROOT, 1.0f));this.add(labe13,new PaneConstraints


(“label3”,“panell”,PaneConstraints.LEFT,0.6300448f);this.add(labe11,new PaneConstraints(“labe11”,“labe13”, PaneConstraints.BOTTOM, 0.68589747f); this.add(label2,new PaneConstraints(“labe12”, “label11”,PaneConstraints.BOTTOM, 0.6730769f); this.add(textField1,new PaneConstraints (“textField1”,PaneConstrains.RIGHT, 0.76868325f);this.add(button1,new PaneConstraints(“button1”, “textField1”,PaneConstraints,RIGHT,0.3442623f); this.add(textField2,new PaneConstraints(“textField2”, “label2,PaneConstraints.RIGHT,0.76868325f); this.add(button4,newPaneConstraints(“button4”, “textField2”,PaneConstraints.RIGHT,0.3442623f); this.add(button3,new PaneConstraints(“button3”, “buttonon2”,PaneConstraints.RIGHT,0.4798851f); }


public static void main(String[]args) { MainFrame frame=new MainFrame(); Frame.setLocation(200,200); Frame.setSize(450,150); Frame.show(); }void button1_actionPerformed(ActionEvent e) {// 加下划线为所添加的代码filer.show(); String dir=filer1.getDirectory();String file=filer1.getFile();if (dir.equals(″null″)&&file.equals(“null”)) return;textField1.setText(dir+file); }


void button2_actionPerformed(ActionEvent e) { String sourceName=textField1.getText(); String desName=textField2.getText();if(sourceName.equals(“”‖desName.equals(“”))retrun;pCopyFile=new PrepareCopyFile();try{ pCopyFile.CopyFile(sourceName,desName); } catch(Exception ee){}}void button3_actionPerformed(ActionEvent e) { MessageDialog mdlg=new MessageDialog (this, “警告” ,”确定要退出吗 ?”,6);


mdlg.setSize(150.80); mdlg.show(); if(mdlg.gteResult()==MessageDialog.NO) retrun; System.exit(0); } void button4_actionPerformed(ActionEvent e) { filer2.show(); String dir=filer2.getDirectory(); String file=filer2.getFile(); if(dir.eqals(“null”)&&file.equals(“null”)) reurn; textField2.setText(dir+file); }}


在拷贝工作开始之前，还需要进行一些准备工作，首先就是实现向列表框中添加新拷贝的文件和删除已经拷贝完成的文件。//源代码清单 6-5-3void addCopyingFile(String sname) {File file=new File(sname);String sfilename=file.getName();List,addItem(sfilename);} viod removeCopyingFile(String sname) { File file=new File(sname); String sfilename=file.getName(); List,remove(sfilename); }

3. 3. 文件拷贝文件拷贝

然后完成拷贝按钮和退出按钮的事件。拷贝按钮事件的具体代码如下所示：String sourceName=textFieldl.getText();String.desName=textField2.getText();if(sourceName.equals(“”)‖desName.equals(“”))retrurn;pCopyFile=new PrepareCopuFile(this.sourceName,desName);pCopyFile.start(); 应用程序首先从文本框中得到用户选择或输入的源文件或目标文件，如果源文件和目标文件都有不为空，就实例化拷贝线程 PrepareCopyFile（该线程目前还不存在），当然首先还必须在类中进行对象定义，方法如下：PrepareCopyFile pCopyFile=null;


退出按钮事件的具体代码如下所示：MessageDialog mdlg=new Message Dialog (this, ″ 警告″，″确定要退出吗？″， 6)； mdlg.setSize(150.80);mdlg.show();if(mdlg.getResult()==MessageDialog.NO) retrun;System.exit(0);MainFrame 类全部源程序清单如下： //源程序清单 6-5 package CopyFile;import java.awt.*;import java.awt.event.*;import borland.jbcl.layout.*;


import borland.jbcl.control.*; import.java.io.*;import.java.util.*;public class MainFrame extends Frame { TextField textFedle1=new textField(); Bubtton button1=new Button(); Label labell=new Label(); Label labe12=new Label(); TextField textField2=new TextField(); Button button2=new Button(); Button button3=new Button(); Filer filer1=new Filer(″ 选择源文件″， Filer.LOAD); Filer filer2=new Filer(this,″ 选择目的文件″， Filer.SAVE);


Button button4=new Button(); PrepareCopyFile pCopyFile=null; Labe label3=new Label(); Panel panel=new Pane(); Panel panel1=new Panel(); PaneLayout paneLayout1=new PaneLayout(); PaneLayout paneLayout2=new PaneLayout(); GroupBox groupBox1=new GroupBox(); List list1=new List(); PaneLayout paneLayout3=new PaneLayout(); Public MainFrame() { try{ jbInit();


} catch (Exception e) { e.printStackTrace(); }} private void jbInit() thows Excption { this.setSize(new Dimension(454.154));this.setBackgrond(new Color(192,192,192));button1.setLabl(″ 浏览．．．″ )btton.addActionListener(new MainFrame_button1_actionAdapter(this)); Btton.addActionListener(new MainFrame_button1_actionAdapter(this)); labell.setAlignment(2);


labell.setText(″源文件″ )；labell.setAlignment(2);label2.setText(“目的文件″ )；button2.setLabel(″复制″ )；button2.addActionListener(new MainFrame_button2_actionAdapter(this));button3.setLabel(″退出″ )；button3.addActionListener(new MainFrame_button3_actionAdapter(this));button4.setLabel(″ 浏览．．．″ )；button4.addActionListener(new MainFrame_button4_actionAdqapter(this));label3.setText(“请输入选择源文件 ( 夹 ) 和目标文件(夹 ):”)；groupBox1.setLayout(paneLayout3);


groupBox1.setLabele(″下载队列″ )；panel1.setLayout(paneLayout2);this.setLayout(paneLayout1);this.add(pane11,new PaneConstraint (″panell″, ″panell″,PaneConstraints.ROOT,0.5f)); panel.add(groupBox1. , new PaneConstraints (“groutpBox1”,“groupBox1”,PaneConstraints.ROOT,1.0f)); GroupBo1.add(list1, new PaneConstraints (“list”,“listl”,PaneConstraint.ROOT,1.0f)); this.add(labe13, new PaneConstraint (“label3”, “panell”,PaneConstraints.LEET,0.6300448f));this.add(labell. ,new PaneConstraint (“labell”,“label3”,PaneConstraints.BOTTOM,0.68589747f))


this.add(textFieldl,new PaneConstraint (“label2”,“labell”,PaneConstraints.BOTTOM,0.6730769f)) this.add(textField,new PaneConstrains (“textField1”,“labell”,PaneConstraints.RIGHT,0.76868325f)) this.add(buttonl,new PaneConstraints (“buttonl”,“textFieldl”,PaneConstraints.RIGHT,0.3442623f)); this.add(button2,new PaneConstraints (“button2”,“label2”,PaneConstraints,BOTTOM,0.57142854f)); this.add(textField2,new PaneConstraints (“textField2”,“Label2”,PaneConstraints.RIGHT,0.76868325f));


this.add(button4,new PaneConstraints (“button4”,“textFileld2”,PaneConstraints.RIGHT,0.3442623f)); this.add(button3,new PaneConstraints (“button3”,“button2”,PaneConstraints.RIGHT,0.4798851f)); } public static void main(String[] args) { MainFrame frame=new MainFrame(); frame.setLocation(200.200); frame.setSize(450,150)l frame.show(); } void buttonl_actionPerformed(ActionEvent e) {


filerl.show();String dir=feler1.getDirectory();String file=feler1.getFile();if(dir.equals(″null″)&&file.equals(″null″)return;textField1.setText(dir+file);} void button2_actionPerformed(ActionEvent e) {String sourceName=textFileld.getText();String desName=textField2.getText();if(sourceName.equals(′′′′)‖desName.equals(′′′′)return;pCopyFile=new PrepareCopyFile(this,sourceName,desName);


pCopyFile.stary();}void addCopyingFile(String sname) {File file=new File(same);String sfilename=file.getName();list1.addItem(sfilename);}void removeCopyingFile(String sname) {File file=new File(sname);String sfilename=file.getName();}void button3_actionPerformed(ActionEvent e) {MessageDialog mdlg=new MessageDialog(this,“ 警告”，确定要退出吗 ?”,6)；


mdlg.setSize(150,80);mdlg.show();if(mdlg.getResult()= =MessageDialog.No)return;System.exit(0);}void button4_actionPerformed(ActionEvent e) {filer2.show();String dir=filer2.getDirectory();String file=filer2.getFile();if(dir.equals(″null″)&&file.equals(″null″))return;textField2.setText(dir+file);}}


本章介绍了 java 的主要可重用类包的结构。具体讲述了 java.lang 、 java.util 和 jave.io 三种 java基本的可重用包中常用的类。 java.lang 提供了 String 类和 StringBuffer 类。 String 类实现一种不能改变的静态字符串， StringBuffer 类实现一种动态可变的字符串。数组是相同类型的数据元素按顺序组成的一种结构数据类型，元素在数组中的相对位置由下标来指明。数组中的每个元素通过数组名加下标进行引用。 java.util 包提供了许多实用的类，如：日期、向量、哈希表、锁和堆栈等。

小结小结

本章还重点介绍了输入输出流操作的基本知识。描述了 java输入输出包中字节输入输出流接口、类的层次继承关系。具体介绍了基本输入输出流中的 InputStream类、OutputStream 类以及 System.in 和 System.out 对象的应用，介绍了主要的文件操作方法。例如 File 类、 FileInputStream类、 FileOutputStream类、 DataInputStream 类、 DataOutputStream 类、 ObjectInputStream类和 ObjectOutputStream类，并用了建立文件和输入输出流并进行输入输出的实例，说明这些类的应用。

小结小结

1.利用 StringBuffer 类编写从键盘读入字符串、整数、实型数并在屏幕显示。2.利用数组，初始化成 10个整数，将其排序。3.利用 Vector 类，实现一个先进先出队列。4.利用 Vector 类，实现一个后进先出栈。5.利用递归计算 N! 的值。6.利用单向链实现一个先进先出队列。7.利用单向链实现一个后进先出栈。8. 什么叫流？简述流的分类。9. 节点流与过滤流各有什么特点？10. 编程完成下列功能：建立两个文件myfiel.txt 和myfile2.txt, 对文件 myfile1.txt 输入内容“ I am a student.”，并将其内容拷贝给myfile2.txt 。然后再将myfile2.txt 中的内容输出到屏幕。

习题习题

11．编程：键盘输入文件所在目录，再输入文件的文件名。判断该文件是否存在，若存在显示文件相关属性（如文件名、文件的绝对路径文件是否可读、可写等）；若文件不存在，显示文件不存在的信息。12．读下面的程序 Main1.java ，然后写出程序功能及运行结果。import java.io.BufferedInputSrteam;import java.io.FileInputStream;import java.io.IOException;Class Main1 { public static void main(String[ ]args) { if(args.length!=1) { System.err,println(Usage:java Main1file); System.exit(-1);

习题习题

}Try {FileInputStream in=new FileInputStream(args[0]);BufferedInputStreambufin=new BufferedInputStream(in,1024);int count,half=bufin.available( )/2;bufin.skip(half);byte[ ]buf=new byte[1024];While ((count=bufin.read(buf,0,buf.length))0)for(int i=;icount;i++) System.out.print((char)buf[i]);System.out.flush( );bufin.close( );}

习题习题

(IOException e) { e.printStackTrace( );}}}运行程序时，输入 java Main1 c:\apple\myfile.java, 其中文件 c:\apple\myfile.java 的内容为“ I am apple!”。13．试述下面程序完成的功能。 inport java.io.*; class Main2 { public static void main(String[ ]args) { if (args.length!=1) { System.err.println(Usage:java Main2output file); Sytem.exit(-1); }

习题习题

FileOutputStream file_out;DataOutputStream data_out;Try { file_out=new FileOutputStream(args[0]) data_out=new DataOutputStream(file_out); char a=a byte b=2; String c=abc; short d=4; byte[ ]b2={65,66,67}; data_out.write(b); data_out.write(b2,0,b2,length); data_out.writeBoolean(true); data_out.writeChar(a);

习题习题

data_out.writeBytes(c);data_out.writeChar(c);data_out.write(123.456);data_out.write(123.456f); data_out.write(678); data_out.write(6781);data_out.writeShort(d); data_out.flush( );System.out.println(Sizeoffilewritten:+data_out.size( ));data_out.close( ); {catch(IOException e) {System.out.println(e); }}}

习题习题

部分习题参考答案部分习题参考答案2. 建一数组 , 初始化成 10个整数 , 再将其排序。 (冒泡排序 )public class XiTi6_2

{public static void main(String[] args) {int i,j,a[ ]={1,6,9,4,3,5,2,7,8,10}; boolean f=false; for(i=0;i<9;i++) {for(j=0;j<9-i;j++) if(a[j]>a[j+1]) {int b=a[j];a[j]=a[j+1];a[j+1]=b; f=true; } if(!f) break; f=false; } for(i=0;i<10;i++) System.out.print(a[i]); } }考虑：数组的 10个整数随机产生或由键盘输入，程序如何写？

部分习题参考答案部分习题参考答案3.利用 Vector 类，实现一个先进先出队列。import java.util.*;public class Queue extends Vector{public void inqueue(Object obj) //入队 { addElement(obj); } public Object outqueue() //出队 { Object b=firstElement(); removeElementAt(0); return b; }

部分习题参考答案部分习题参考答案 public static void main(String args[]) {Queue q1= new Queue(); q1.inqueue("111"); q1.inqueue("222"); Object bb=q1.outqueue(); System.out.println(bb); q1.inqueue("333"); bb=q1.outqueue(); System.out.println(bb); bb=q1.outqueue(); System.out.println(bb); }} 运行结果

运行结果：111

222

333

部分习题参考答案部分习题参考答案

import java. io.*; public class XiTi6_10public static void main(String[]args)throws Exception {File f = new File("d:\\XiTi6\\myfile1.txt"); FileWriter f1= new FileWriter(f); f1.write("I am a student."); f1.close(); char a[]=new char[(int)f.length()]; FileReader f2 = new FileReader(f); f2.read(a); f2.close();

10. 编程完成下列功能：建立两个文件myfiel.txt 和myfile2.txt,对文件myfile1.txt输入内容“ I am a student.”,并将其内容拷贝给myfile2.txt 。然后再将myfile2.txt 中的内容输出到屏幕。

部分习题参考答案部分习题参考答案 f= new File("d:\\XiTi6\\myfile2.txt"); // 上句可改为 f=new File(f.getParent()+"\\myfile2.txt"); f1 = new FileWriter(f); f1.write(a); f1.close(); f2 = new FileReader(f); char b[]=new char[(int)f.length()]; f2.read(b); System.out.println(b); f2.close(); }}

Documents

JAVA 网络编程基础