Java毕业设计外文翻译

1、毕业设计（论文）外文文献翻译译文：Java I/O 系统 1对编程语言的设计者来说，创建一套好的输入输出（ I/O ）系统，是一项难度极 高的任务。这一类可以从解决方案的数量之多上看出端倪。 这个问题就难在它要面对的可能 性太多了。不仅是因为有那么多的 I/O 的源和目的（文件，控制台，网络连接等等） 而且还有很多方法（顺序的，随机的，缓存的，二进制的，字符方式的，行的，字的Java 类库的设计者们用“创建很多类”的办法来解决这个问题。坦率地说， Java I/O 系统的类实在太多了，以至于初看起来会把人吓着（但是，具有讽刺意味的是， 这种设计实际上是限制了类的爆炸性增长） 。此外， Java

2、 在 1.0 版之后又对其 I/O 类 库进行了重大的修改， 原先是面向 byte 的，现在又补充了面向 Unicode 字符的类库。 为了提高性能，完善功能， JDK1.4 又加了一个 nio（ 意思是“ new I/O ”。这个名字会 用上很多年 ） 。这么以来，如果你想对 Java 的 I/O 类库有个全面了解，并且做到运 用自如，你就得先学习大量的类。此外，了解 I/O 类库的演化历史也是相当重要的。 可能你的第一反应是 “别拿什么历史来烦我了， 告诉我怎么用就可以了！ ”但问题是， 如果你对这段一无所知，很快就会被一些有用或是没用的类给搞糊涂了。本文会介绍 Java 标准类库中的各种

3、 I/O 类，及其使用方法。File 类 在介绍直接从流里读写数据的类之前，我们先介绍一下处理文件和目录的类。 你会认为这是一个关于文件的类， 但它不是。你可以用它来表示某个文件的名字， 也可以用它来表示目录里一组文件的名字。 如果它表示的是一组文件， 那么你还可以 用 list（ ） 方法来进行查询，让它会返回 String 数组。由于元素数量是固定的，因 此数组会比容器更好一些。如果你想要获取另一个目录的清单，再建一个 File 对象 就是了。目录列表器假设你想看看这个目录。有两个办法。一是不带参数调用 list（ ） 。它返回的是 File 对象所含内容的完整清单。但是，如果你要的是一个

4、 限制性列表 （restricted list） 的话 比方说， 你想看看所有扩展名为 .java 的文件 那么你就得使 用 目录过滤器 了。这是一个专门负责挑选显示 File 对象的内容的类。FilenameFilter 接口的声明：public interface FilenameFilter boolean accept(File dir, String name);accept( ) 方法需要两个参数，一个是 File 对象，表示这个文件是在哪个目录里 面的；另一个是 String ，表示文件名。虽然你可以忽略它们中的一个，甚至两个都 不管，但是你大概总得用一下文件名吧。记住， lis

5、t( ) 会对目录里的每个文件调用 accept( ) ，并以此判断是不是把它包括到返回值里；这个判断依据就是 accept( ) 的返回值。切记，文件名里不能有路径信息。为此你只要用一个 String 对象来创建 File 对象，然后再调用这个 File 对象的 getName( )就可以了。它会帮你剥离路径信息 (以 一种平台无关的方式) 。然后再在 accept( ) 里面用正则表达式 (regular expression) 的 matcher 对象判断， regex 是否与文件名相匹配。兜完这个圈子， list( ) 方法返 回了一个数组。匿名内部类这是用匿名内部类来征程程序的绝佳机

6、会。下面我们先创建一个返回 FilenameFileter 的 filter() 方法。/ Uses anonymous inner classes.import java.io.*;import java.util.*;import com.bruceeckel.util.*;public class DirList2 public static FilenameFilterfilter( final String afn) / Creation of anonymous inner class:return new FilenameFilter() String fn = afn;publ

7、ic boolean accept(File dir, String n) / Strip path information:String f =new File(n).getName();return f.indexOf(fn) != -1; / End of anonymous inner classpublic static void main(String args) File path =new File( . );String list;if (args.length = 0)list = path.list();elselist = path.list(filter(args0)

8、;Arrays.sort(list,new AlphabeticComparator();for (int i = 0; i list.length; i+)System.out.println(listi);注意， filter( )的参数必须是 final 的。要想在匿名内部类里使用其作用域之外的对象，只能这么做。这是对前面所讲的代码的改进， 现在 FilenameFilter 类已经与 DirList2 紧紧地 绑在一起了。不过你还可以更进一步，把这个匿名内部类定义成 list() 的参数，这 样代码会变得更紧凑：/ Building the anonymous inner class

9、in-place.import java.io.*;import java.util.*;import com.bruceeckel.util.*;public class DirList3 public static void main( final String args) File path =new File( . );String list;if (args.length = 0)list = path.list();elselist = path.list(new FilenameFilter() public booleanaccept(File dir, String n) S

10、tring f =new File(n).getName();return f.indexOf(args0) != -1;);Arrays.sort(list,new AlphabeticComparator();for (int i = 0; i list.length; i+)System.out.println(listi);现在该轮到 main() 的参数成 final 了，因为匿名内部类要用它的 arg0. 这个例子告诉我们， 可以用匿名内部类来创建专门供特定问题用的， 一次性的类。 这种做法的好处是， 它能把解决某个问题的代码全部集中到一个地方。 但是从另一角 度来说，这样做会使代

11、码的可读性变差，所以要慎重。查看与创建目录File 类的功能不仅限于显示文件或目录。它还能帮你创建新的目录甚至是目录 路径(directorypath) ，如果目录不存在的话。 此外它还能用来检查文件的属性 (大小， 上次修改的日期， 读写权限等 ) ，判断 File 对象表示的是文件还是目录， 以及删除文 件。renameTo( ) 这个方法会把文件重命名成 ( 或者说移动到 ) 新的目录，也就是参数 所给出的目录。而参数本身就是一个 File 对象。这个方法也适用于目录。输入与输出I/O 类库常使用 流(stream) 这种抽象。所谓 流是一种能生成或接受数据的， 代表数据的源和目标的对象

12、。流把 I/O 设备内部的具体操作给隐藏起来了。正如 JDK 文档所示的， Java 的 I/O 类库分成输入和输出两大部分。所有 InputStream 和 Reader 的派生类都有一个基本的，继承下来的，能读取单个或 byte 数组的 read( ) 方法。同理，所有 OutputStream 和 Writer 的派生类都有一个基本的， 能写入单个或 byte 数组的 write( ) 方法。但通常情况下， 你是不会去用这些方法的； 它们是给其它类用的 而后者会提供一些更实用的接口。 因此，你很少会碰到只 用一个类就能创建一个流的情形， 实际上你得把多个对象叠起来， 并以此来获取所需 的

13、功能。 Java 的流类库之所以会那么让人犯晕，最主要的原因就是 你必须为创建一 个流而动用多个对象 。我们最好还是根据其功能为这些 class 归个类。 Java 1.0 的类库设计者们是从 决定“让所有与输入相关的类去继承 InputStream ”入手的。同理，所有与输出相关 的类就该继承 OutputStream 了。添加属性与适用的接口使用分层对象 (layered objects) ，为单个对象动态地，透明地添加功能的做 法，被称为 DecoratorPattern 。 ( 模式是 Thinkingin Patterns (with Java)的主题。 )Decorator 模式要

14、求所有包覆在原始对象之外的对象，都必须具有与之完全相 同的接口。这使得 decorator 的用法变得非常的透明 - 无论对象是否被 decorate 过， 传给它的消息总是相同的。这也是 Java I/O 类库要有 filter( 过滤器) 类的原因： 抽象的 filter 类是所有 decorator 的基类。 (decorator 必须具有与它要包装的对 象的全部接口，但是 decorator 可以扩展这个接口，由此就衍生出了很多 filter 类)。Decorator 模式常用于如下的情形：如果用继承来解决各种需求的话，类的数量 会多到不切实际的地步。 Java 的 I/O 类库需要提

15、供很多功能的组合， 于是 decorator 模式就有了用武之地。但是 decorator 有个缺点，在提高编程的灵活性的同时 ( 因为 你能很容易地混合和匹配属性 ) ，也使代码变得更复杂了。 Java的 I/O 类库之所以会 这么怪，就是因为它 必须为一个 I/O 对象创建很多类 ，也就是为一个 核心I/O 类 加上很多 decorator 。为 InputStream 和 OutputStream 定 义 decorator 类 接 口 的 类 ， 分 别 是 FilterInputStream 和 FilterOutputStream 。 这 两 个 名 字 都 起 得 不 怎 么 样

16、 。 FilterInputStream 和 FilterOutputStream 都继承自 I/O 类库的基类 InputStream 和 OutputStream ，这是 decorator 模式的关键 （ 惟有这样 decorator 类的接口才能与 它要服务的对象的完全相同 ） 。用 FilterInputStream 读取 InputStreamFilterInputStream 及其派生类有两项重要任务。 DataInputStream 可以读取各 种 primitive 及 String 。 （ 所有的方法都以 read 打头，比如 readByte（ ） ， readFloat

17、（ ） 。它，以及它的搭档 DataOutputStream ，能让你通过流将 primitive 数据从一个地方导到另一个地方。这些 地方都列在表 12-4 里。其它的类都是用来修改 InputStream 的内部行为的： 是不是做缓冲， 是不是知道 它所读取的行信息 （ 允许你读取行号或设定行号 ），是不是会弹出单个字符。 后两个看 上去更像是给编译器用的 （也就是说，它们大概是为 Java编译器设计的 ） ，所以通常 情况下，你是不大会用到它们的。不论你用哪种 I/O 设备，输入的时候，最好都做缓冲。所以对 I/O 类库来说，比 较明智的做法还是把不缓冲当特例 （ 或者去直接调用方法 ）

18、 ，而不是像现在这样把缓冲 当作特例。外文原文：JAVA I/O SystemCreating a good input/output (I/O) system is one of the more difficult tasks for the language designer.This is evidenced by the number of different approaches. The challenge seems to be in covering all eventualities. Not only are there different sources and sin

19、ks of I/O that you want to communicate with (files, the console, network connections), but you need to talk to them in a wide variety of ways (sequential, random-access, buffered, binary, character, by lines, by words, etc.).The Java library designers attacked this problem by creating lots of classe

20、s. In fact, there are so many classes for Javas I/O system that it can be intimidating at first (ironically, theJava I/O design actually prevents an explosion of classes). There was also a significant change in the I/O library after Java 1.0, when the original byte-oriented library was supplemented

21、with char-oriented, Unicode-based I/O classes. As a result there are a fair number of classes to learn before you understand enough of Javas I/O picture that youuse it properly. In addition, its rather important to understand the evolution history of theI/O library, even if your first reaction is“ d

22、on t bojtuhsetr smhoe w imthe h hisotwor tyo,use it! ”Th e problem is that without the historical perspective you will rapidly become confused with some of the classes and when you should and shouldnt use them.This article will give you an introduction to the variety of I/O classes in the standard J

23、ava library and how to use them.The File classBefore getting into the classes that actually read and write data to streams, we utility provided with the library to assist you in handling file directory issues.The File class has a deceiving name you might think it refers to a file, but it doesncan re

24、present either the name of a particular file or the names of a set of files in a directory. If it s a set of files, you can ask for the set with the )l imste( thod, and this returns an array of String. It makes sense to return an array rather than one of the flexible container classes because the nu

25、mber of elements is fixed, and if you want a different directory listing you just create a different File object. In fact,“ FilePath ” would have been a better naclass. This section shows an example of the use of this class, including the associated FilenameFilter interface.A directory listerSuppose

26、 you d like to see a directory listing. The File object can be lisdt ein two ways. If you call list( ) with no arguments, you lgl et the full list that the File object contains. However, if you want a restricted list for example, if you want all of the files with an extension of .java then you use a

27、 “ directoryf ilter, wh”ic h is a class that tells how to select the File objects for display.The DirFilter class “implements th”e interface FilenameFilter. It us eful to see how simple the FilenameFilter interface is: public interface FilenameFilter boolean accept(File dir, String name);The accept(

28、 ) method must accept a File object representing the directory that a particular file is found in, and a String containing the name of that file. You might choose to use or ignore either of these arguments, but you will probably at least use the file name. Remember that the list( ) method is calling

29、 accept( ) for each of the file names in the directory object to see which one should be includedthis is indicated by the boolean result returned by accept( ).To make sure the element you rew orking with is only the file name and contains no path information, all you have to do is take the String ob

30、ject and create a File object out of it, then call getName( ), which strips away all the path information (in a platform-independent way). Then accept( ) uses the a regular expression matcher object to see if the regular expression regex matches the name of the file.Using accept(),the list()method r

31、eturns an array.Anonymous inner classesThis example is ideal for rewriting using an anonymous inner class. As a first cut, a method filter( ) is created that returns a reference to a FilenameFilter: / Uses anonymous inner classes.import java.io.*;import java.util.*;import com.bruceeckel.util.*;publi

32、c class DirList2 public static FilenameFilterfilter( final String afn) / Creation of anonymous inner class:return new FilenameFilter() String fn = afn;public boolean accept(File dir, String n) / Strip path information:String f =new File(n).getName();return f.indexOf(fn) != -1; / End of anonymous inn

33、er classpublic static void main(String args) File path =new File( . );String list;if (args.length = 0)list = path.list();elselist = path.list(filter(args0);Arrays.sort(list,new AlphabeticComparator();for (int i = 0; i list.length; i+)System.out.println(listi);Note that the argument to filter( ) must

34、 be final. This is required by the anonymous inner class so that it can use an object from outside its scope.This design is an improvement because the FilenameFilter class is now tightly bound to DirList2. However, you can take this approach one step further and define the anonymous inner class as a

35、n argument to list() , in which case it s even smaller:/ Building the anonymous inner class in-place. import java.io.*; import java.util.*;import com.bruceeckel.util.*;public class DirList3 public static void main( final String args) File path =new File( . );String list;if (args.length = 0)list = pa

36、th.list();elselist = path.list( new FilenameFilter() public booleanaccept(File dir, String n) String f =new File(n).getName();return f.indexOf(args0) != -1;);Arrays.sort(list,new AlphabeticComparator();for (int i = 0; i list.length; i+)System.out.println(listi);The argument to main( ) is now final,

37、since the anonymous inner class uses args0 directly.This shows you how anonymous inner classes allow the creation of quick-and-dirty classes to solve problems. Since everything in Java revolves around classes, this can be a useful coding technique. One benefit is that it keeps the code that solves a

38、 particular problem isolated together in one spot. On the other hand, it is not always as easy to read, so you must use it judiciously.Checking for and creating directoriesThe File class is more than just a representation for an existing file or directory. You can also use a File object to create a

39、new directory or an entire directory path if it doesn You can also look at the characteristics of files (size, last modification date, read/write), see whether a File object represents a file or a directory, and delete a file.The first method thats exercised b) yi sm reainna(meTo( ), which allows yo

40、u to rename(or move) a file to an entirely new path represented by the argument, which is another File object. This also works with directories of any length.Input and outputI/O libraries often use the abstraction of a stream, which represents any data source or sink as an object capable of producin

41、g or receiving pieces of data. The stream hides the details of what happens to the data inside the actual I/O device.The Java library classes for I/O are divided by input and output, as you can see by looking at the online Java class hierarchy in the JDK documentation. By inheritance, everything der

42、ived from the InputStream or Reader classes have basic methods called read( ) for reading a single byte or array of bytes. Likewise, everything derived from OutputStream or Writer classes have basic methods called write( ) for writing a single byte or array of bytes. However, you won t generally use

43、 these methods; they exist so that other classes can use them these other classes provide a more useful interface. Thus, you ll rarely create your stream object by using a single class, but instead will layer multiple objects together to provide your desired functionality. The fact that you create m

44、ore than one object to create a single resulting stream is the primary reason that Java sst ream library is confusing.It hse lpful to categorize the classes by their functionality. In Java 1.0, the library designers started by deciding that all classes that had anything to do with input would be inh

45、erited from InputStream and all classes that were associated with output would be inherited from OutputStream.Adding attributes and useful interfacesThe use of layered objects to dynamically and transparently add responsibilities to individual objects is referred to as the Decorator pattern. The dec

46、orator pattern specifies that all objects that wrap around your initial object have the same interface. This makes the basic use of the decorators transparent you send the same message to an object whether it s been decorated or not. This is the reason for the existence of the“ filterJava I/O librar

47、y: the abstract “ filter cla”ss is the base class for all the decorators. (A decorator must have the same interface as the object it decorates, but the decorator can also extend the interface, which occurs in several of the“ filter ” classes).Decorators are often used when simple subclassing results

48、 in a large number of subclasses in order to satisfy every possible combination that is neededso manysubclasses that it becomes impractical. The Java I/O library requires many different combinations of features, which is why the decorator pattern is used. There is a drawback to the decorator pattern

49、, however. Decorators give you much more flexibility while you writing a program (since you can easily mix and match attributes), but they add complexity to your code. The reason that the Java I/O library is awkward to use is that you must create many classes the “core ” I/O type plus all the decoratoirns order to get the single I/O object that you want.The classes that provide the decorator interface to control a particu