Java学习笔记 完整版

Java的白皮书为我们提出了Java语言的11个关键特性
(1)Easy:Java的语法比C++的相对简单，另一个方面就是Java能使软件在很小的机器上运行，基础解释其和类库的支持的大小约为40kb，增加基本的标准库和线程支持的内存需要增加125kb。
(2)分布式:Java带有很强大的TCP/IP协议族的例程库，Java应用程序能够通过URL来穿过网络来访问远程对象，由于servlet机制的出现，使Java编程非常的高效，现在许多的大的web server都支持servlet。
(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同，在与多重继承的处理及Java的原类模型。
(4)健壮特性:Java采取了一个安全指针模型，能减小重写内存和数据崩溃的可能型。
(5)安全:Java用来设计网路和分布系统，这带来了新的安全问题，Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的比较好。
(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行，编译器产生的指令字节码(Javabytecode)实现此特性，此字节码可以在任何机器上解释执行。
(7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好。
(8)多线程:Java处理多线程的过程很简单，Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一。
(9)Applet和servlet:能够在网页上执行的程序叫Applet，需要支持Java的浏览器很多，而applet支持动态的网页，这是很多其他语言所不能做到的。
基本概念
1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率。
2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。
3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。
4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。
5.对象的3个主要特性
behavior---说明这个对象能做什么.
state---当对象施加方法时对象的反映.
dentity---与其他相似行为对象的区分标志.
每个对象有唯一的indentity 而这3者之间相互影响.
6.类之间的关系: use-a :依赖关系 has-a :聚合关系 is-a :继承关系--例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)
7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。
例:Data类的构造器叫Data
new Data()---构造一个新对象，且初始化当前时间.
Data happyday=new Data()---把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者
是不同的.new返回的值是一个引用。
构造器特点:构造器可以有0个，一个或多个参数 构造器和类有相同的名字 一个类可以有多个构造器 构造器没有返回值 构造器总是和new运算符一起使用.
8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。
9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包.java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。
10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。
11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。
12.多态:在java中，对象变量是多态的.而java中不支持多重继承。
13.动态绑定:调用对象方法的机制。
(1)编译器检查对象声明的类型和方法名。
(2)编译器检查方法调用的参数类型。
(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。
(4)当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。
(5)动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。
14.final类:为防止他人从你的类上派生新类，此类是不可扩展的。
15.动态调用比静态调用花费的时间要长。
16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。
例: public abstract string getDescripition
17.Java中的每一个类都是从Object类扩展而来的。
18.object类中的equal和toString方法。
equal用于测试一个对象是否同另一个对象相等。
toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示.
(toString 方法是一个很重要的方法)
19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。
20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小。
21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。
22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。
能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大.
1.在运行时分析类的能力。
2.在运行时探察类的对象。
3.实现通用数组操纵代码。
4.提供方法对象。
而此机制主要针对是工具者而不是应用及程序。
反射机制中的最重要的部分是允许你检查类的结构.用到的API有:
java.lang.reflect.Field 返回字段.
java.reflect.Method 返回方法.
java.lang.reflect.Constructor 返回参数.
方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。
23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。
24.接口不是一个类，而是对符合接口要求的类的一套规范。
若实现一个接口需要2个步骤:　
1.声明类需要实现的指定接口。
2.提供接口中的所有方法的定义。
声明一个类实现一个接口需要使用implements 关键字
class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口.
25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable
26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。
例:ActionListener 接口监听.
类似的API有:java.swing.JOptionPane
java.swing.Timer
java.awt.Tookit
27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。
28.内部类:一个内部类的定义是定义在另一个内部的类。
原因是:
1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。
2.对于同一个包中的其他类来说，内部类能够隐藏起来。
3.匿名内部类可以很方便的定义回调。
4.使用内部类可以非常方便的编写事件驱动程序。
29.代理类(proxy):
1.指定接口要求所有代码
2.object类定义的所有的方法(toString equals)
30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型

31、由封装对象转换为基本数据类型：obj.XXXValue()；obj为封装类的对象，XXX为该封装对象所表示的
基本数据类型。
32、由字符串转换为基本数据类型：obj.parseXXX(String str)；obj是封装类的对象，XXX为该封装对象
所表示的基本数据类型。
33、由字符串转换为封装对象：obj.valueOf(String str)。
34、由封装对象转换为字符串：obj.toString()。
35、由基本数据类型转换为字符串：obj.toString(XXX value)。
36、不等于：!=
37、运算符instanceof,如v1 instanceof v2。检查对象v1是否为class v2的一个实例。
38、逻辑运算符两边的式子需属于boolean。与C++不同，C++中，0之外的整数都视为true。
39、位（Bitwise）逻辑运算符: & ,v1 & v2。位AND，若相对位都为1，则1，否则0
| ,v1 | v2。位OR，若相对位都为0，则0，否则1 ^ ,v1 ^ v2。位XOR，若相对的位有相同值，则0，否则1~ ,~v1。v1的补码，1变成0，0变成1。 v1和v2需属于整数类型。
40、Java不支持操作重载，也不支持C++的::和>>以及<<运算符。
41、常量的指定：static final int NUM =1。
42、数组定义：int num []; or int [] num; num=new int [15]; or int [] num=new num[15]; or int
num[]={1,2,3,4,5};
43、若二维数组的第2维的长度不同，由于数组变量本身是参考类型，可将第1维指向另一个数组。
44、复制数组：void arraycopy(Object src,int srcPosition,Object dest,int destPosition,int
length) or clone() for example int [] newA=(int [])A.clone();
45、Arrays类提供的一些数组运算，如排序和搜索
static void sort(dataType[] data):将数组data内的元素由小到大排列（使用quicksort）
static void sort(dataType[] data,int fromIndex,int toIndex)
static int binarySearch(dataType[] data,dataType key)：利用二进制搜索的方式搜索数组data
（必须事先排过序）内的元素key。若搜索到，则返回key在data中的位置；若无法找到，返回值为（－插
入点－1），插入点（insert point）为第一个大与所要搜索元素值的索引。
static void fill(dataType[] data,dataType val):将数组内的各元素设置为val。
static void fill(dataType[] data,int fromIndex,int toIndex,dataType val)
46、在Java中，char数组及String类并不以'\0'为结尾。char数组并不等于String对象，数组是可变的，
但String对象是不变的。
47、将char数组转换成一个String对象。char[] data={'s','t','r','i','n','g'};String str=new
String(data);
48、length()得到一个字符串的长度，而length可用来得到一个数组所含元素的数目。
49、由于Java的对象为引用类型，因此，string1＝＝string2，只是比较变量string1和string2是否指向
同一个地址，并不会比较字符串的内容。
50、int compareTo(String str):s1.compareTo(s2)。若s1和s2相等，则返回0；若s1>s2，则返回值大于
0；若s1<s2，则返回值小于0。
int compareToIngnoreCase(String str):s1.compareToIngoreCase(s2)。忽略大小写。
boolean equals(Object obj):s1.equals(s2)。
boolean equalsIgnoreCase(String str):s1.equalsIgnoreCase(s2)。
51、搜索和读取部分字符串的操作：
boolean startsWith(String str):检查str是否在字符串的最前面
boolean endsWith(String str)
int indexOf(char ch):得到ch第一次在字符串中出现的位置，若无法找到则返回－1
int indexOf(String str)
int lastIndexOf(char ch):由后面开始搜索，得到ch第一次在字符串中出现的位置，若无法找到返
回－1
int lastIndexOf(String str)
String substring(int begin):生成一个新的字符串，它包含原有字符串位置begin至最末端的所有
字符
String substring(int begin,int end)
52、StringTokenizer(String str):使用默认的分界符来分析一个字符串，它们分别为：'，'\t'，'\n'，'\r'，'\f'。
StringTokenizer(String str,String delimiter):使用所指定的delimiter来分析字符串
53、StringBuffer类是用来生成字符串缓冲区，这种字符串称为可变字符串。StringBuffer对象的默认容
量是16个字符。
54、StringBuffer无法像String对象一样直接将字符串指定给StringBuffer对象，例如StringBuffer
myString3="this is worong"。必须使用new生成StringBuffer对象。
55、StringBuffer对象有容量和长度之分，容量是不变的，长度是可变的。长度小于等于容量，表示实际
存储的字符数目。
56.int capacity()：返回StringBuffer对象的容量。
int length()：返回StringBuffer对象的长度。
StringBuffer append(dataType data):将data加入StringBuffer对象后面
StringBuffer insert(int offset,dataType data)：将data插入到offset位置前
String toString():将StringBuffer对象转换为String对象。
57、当存储的字符串长度超过其容量，容量会改为原来容量的两倍加上2。预先指定足够的容量效率较高
58、数据成员代表类内所声明的变量，分为static（类变量）和non-static（实例变量）
59、类内的方法分为static（类方法）和non-static（实例方法）
60、每个对象都有一个属于自己的实例变量和变量值，通过对象来存取实例变量。
61、每个类 只有一个类变量，属于该类的对象会共享类变量。不需要通过对象来存取类变量。
62、一个static方法只能存取类的static数据；一个static方法只能存取类的static方法；无法在算他题
词方法中使用this；一个static方法无法被非static方法所替代。
63、构造函数并没有返回值，它需和所在的类同名，如果所用的类并没有构造函数，Java编译器会自动生
成一个默认构造函数（不含参数）。
64、Java中，new是不可省略的，使用new表示该变量的内存是动态分配的，但必须记得将该内存释放掉。
65、基本数据类型将其值存放在堆栈中，而引用数据类型是将其引用存在堆栈中，但其所引用的对象则是
存在堆（heap）中。
66、Java有引用数据类型和基本数据类型，但只有一种传递方法，即通过数值传递（pass-by-value），
并没有通过引用传递（pass-by-reference）。方法接收到的是一份原来值的复制，对于基本数据类型，
所接收到的是一份该数据值的复制；而对于引用数据类型，所接收到的是一份该引用值的复制，而不是该
引用本身。
67、如果要在Java中达到像C/C++的通过引用传递的效果，一个办法是把数组作为参数。
68、除了声明为private的数据成员外，同一个包的类可以继承其他所有的数据成员，而其他包的类可以
继承public和protected的数据成员。这些准则适用于所有的数据成员（类或实例变量），同时也适应于
方法，但父类的构造函数并不会被继承。对定义为final的成员也无法被继承。
69、在使用方法重载时无法在同一个类中声明签名（方法名、参数数目、参数类型）相同但返回值不同的方法。

70、将方法重载称为静态方法绑定或先期绑定，这是由于在编译时编译器会根据参数的类型和数目来决定
调用哪个方法，而不是在执行时决定。
71、可以将许多的类放在同一个文件中，但只能有一个类声明为public，其他的类称为辅助（helper）类
，辅助类也可包含main()，但会被忽略。
72、以下情况，此类必须声明为abstract：
该类有一个或超过一个abstract方法（声明但没有定义的方法）
该类从一个abstract类继承一个或超过一个abstract方法，但没有提供这些方法的实现方法
该类实现一个接口，但没有将该接口所有的方法加以实现
73、abstract方法不能被声明为private，因为abstract类会被其他类继承。无法生成一个abstract类的
对象，但可声明一个abstract类类型的变量。
74、多态（polymorphism）代表同样的表示法可用来处理多种不同类型的数据。重载是多态的一种，称为
静态多态。一般的多态是动态多态，是在执行时才根据对象来决定一个方法的行为，这是一种动态方法绑
定（后期绑定）。
75、C++中，多态通过虚拟函数实现，Java使用abstract类实现多态。
76、接口是用来表明一个类能做什么，但不表明如何完成（实际的工作会交由使用此接口的程序员来完成
），因此常使用接口来制定类设计的协议（protocol），而Java API设计的主要精神就是将接口和实际类
的实现分开，因为不同的系统可能会有不同的实现方法，但用户所使用的方式却是一样的，这可解决可移
植性问题。
77、接口和类一样可当作一种数据类型，但和abstract类一样，无法用它来生成新的对象。
78、一个接口是一群常量和abstract方法的组合，接口内的常量总是为public和static以及final（因此
，有时我们只会单纯地使用接口来存储用户自定义地常量而不包含任何方法），而方法总为public和
abstract，即使没有明确地声明。
79、一个类可通过关键字implements来实现接口，而类可实现一个以上的接口。
80、和类定义相同，一个接口可通过extends来继承其他接口，不同的是，接口支持多重继承，这是由于
接口内方法未定义，并不会产生类多重继承的问题。
81、和abstract类不同的是，当一个类实现接口，此类必须定义所有接口内的方法。
82、将接口和abstract类结合在一起。除了使用接口来进行多重继承外，一个常用的设计方式是使用接口
来生成新的数据类型，但不会被特定的实现方式限制住，这有点类似基本数据类型，并不会生成该类型的
对象，也没有实现任何方法。而abstract类也可用来定义新的数据类型，但会选择性地实现共同地方法。
当然，一般地类也可用来定义新地数据类型，但会实现全部地方法。因此，在设计一个较有扩充性地数据
类型时，往往会以接口为最上面一层，再以abstract类为中间的一层，而下面则为一般的类。
83、将类定义在另一个类内称为内部类。
84、匿名类是一种没有名称的内部类，它也没有构造函数。如：
button.addActionListener(new ActionListener()
{ 用来实现ActionListener的程序主体 }//此对象仅用于addActionListener()中 )
85、在Java中，最常使用内部类和匿名类的地方是GUI。
86、由于匿名类并没有名称，因此生成的类文件会用数字表示，如Outer＄1.class
87、垃圾回收：一个较好的方法是将不用的对象设为null。
88、强制执行垃圾回收：System.gc()。
89、finalize()是在对象释放前先执行，它是所有Java对象都会继承的方法。
90、生成包：只要在所定义的类程序的最前面加上package{packageName};放在import之前
91、包命名：小写字母，使用顺序反过来的域名。
92、包内的类需声明为public，否则不属于此包的方法无法使用它。
93、采用JAR文件方便维护和安装，一个JAR文件往往包含多个包，Sun J2SE所提供的标准类放在rt.jar中。
94、J2SE提供工具软件jar来生成JAR文件：
jar cvf <jar file> <class file>
jar cmvf <manifest> <jar file> <class file> 用m来包含自定义的说明(manifest)文件
Manifest.mf。
95、将创建的包输入进来：用import com.mycompany.shape.*;非import com.mycompany.shp;另外还需将
此JAR文件包含在类路径中，在Windows中需要设置：SET CLASSPATH=.;shapr.jar。或者可以使用：java -classpath <class path> <class file>
96、由于和对象相关的变量属于引用类型，使用obj1＝obj2；obj1只是得到一份obj2应用的副本，而不是obj2对象本身。
97、使用clone()来复制一个对象，clone()从Object类继承。obj1＝obj2.clone();obj2必须是可复制的。
98、为了使一个用户自定义的类对象可被复制，必须使用接口Cloneable，并声明一个public方法clone()
来执行复制工作。
99、若要完成深度复制(deep copy)（包含所参考的对象和其相关的对象），则需根据对象间的阶层关系
一层层地复制下去。
100、Reflection又称introspection，因为它允许执行中地Java程序来进行自我检查，可以得到一个对象
所属类定义的成员及相关的数据，这是Java特有的功能。
101、Reflection提高像功能指针一样的功能，可在程序执行时才动态提高所以执行的类对象方法名称与
所要输入的参数。
102、首先得到一个Class对象，有两种方法
由既存类对象，使用getClass()得到一个类对象，如obj.getClass(); 使用Class.forName(String className)
103、其次，使用Class提供的方法来得到该类的相关数据
String getName(); 用来得到该类的名称
Method[] getDeclaredMethods(); 得到所有在该类内所声明的方法名称
Method[] getMethods(); 得到所有在该类的方法名称，包含由父类继承的方法
Method getMethod(String methodName, Class[] parameterTypes); 得到一个Method对象
104、最后，使用Method所提供的方法来执行所要执行的方法
Object invoke(Object methodObj,Object[] parameters); 发生错误时，生成
InvocatioTargetException
105、利用Reflection功能来执行类内的方法时，方法的输入数据类型是较特殊的地方，语法为：
typeName.class，如int[]为int[].class,int为int.class,String为String.class。输入的参数必须为对
象（Object）
106、为了知道一个Java程序的执行效率，以提供改进程序的方法，Java提供了Java profiling的功能。
java -Xrunhprof:help 用于查询Java profiling可供使用的选项。如，了解程序中各种方法执行时间的
比例，可使用java -Xrunhprof:cpu=times className。会产生一个java.hprof.txt文件。
107、Throwable是所有Java程序中错误处理的父类，有两种资类：Error和Exception。
108、Error：表示由JVM所侦测到的无法预期的错误，由于这是属于JVM层次的严重错误，导致JVM无法继
续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，顶多只能显示错误信息。
109、Exception：表示可恢复的例外，这是可捕捉到的，因此，当例外发生时，可采取一些恢复的行动。
110、例外的处理方式之一：如果要忽略程序中可能发生的例外，而交由其他程序处理，可将这些例外直
接返回所调用的程序，而所调用的程序必须处理这些例外或是将它们再往上返回所调用的程序。
111、例外的处理方式之二：如果要再程序中直接处理这些例外，则可使用try...catch（...finally）的方式。
112、finally可以省略。如果使用，finally内的程序一定会被执行，一般用来进行最后的清理工作，如
关闭所打开的系统资源。
113、Throwable所提供的方法：
String toString()：代表该Throwable对象的字符串表示法。
String getMessage()：返回和该对象相关的错误信息。
void printStackTrace()：将例外生成所发生的途径显示出来。
void printStackTrace(PrintStream out)：输出到一个PrintStream的数据流中，借此可将信息写到一个文件。
void printStackTrace(PrintWriter out)：输出到一个PrintWriter的数据流中。
114、try...catch也是一种区段式的构架，对子变量的可见范围也必须遵循同样的规则，有时为了让
catch（或finally）区段能使用try区段内的变量，需要将变量声明再try...catch的区段外。
115、当程序需要捕捉数个不同的例外时，需要特别注意这些例外的顺序。应该按照类之间的阶层关系放
置，越是基本的类越需放在后面的catch()区段。
116、一个例外类至少需要包含一个默认的构造函数（用来显示默认的信息）及一个以String对象为参数
的构造函数（用来显示用户提供的自订信息）。
117、C/C++只能提供字节流，在Java中，还有字节（byte）流和字符（character）流之分。

118、字节流：OutputStream提供的方法：
void write(int b):写入一个字节的数据
void write(byte[] buffer):将数组buffer的数据写入流
void write(byte[] buffer,int offset,int len):从buffer[offset]开始，写入len个字节的数据
void flush():强制将buffer内的数据写入流
void close():关闭流
119、InputStream提供的方法：
int read():读出一个字节的数据，如果已达文件的末端，返回值为－1
int read(byte[] buffer):读出buffer大小的数据，返回值为实际所读出的字节数
int read(byte[] buffer,int offset,int len)
int available():返回流内可供读取的字节数目
long skip(long n):跳过n个字节的数据，返回值为实际所跳过的数据数
void close():关闭流
120、字符流。Reader、Writer类中提供的方法与字节流相同，只是参数内的byte[]需改为char[]
121、Stream根据功能可分为数据侦听器流（data Sink Stream，侦听器：内存、管道、文件）和进程流
（Processing Stream）
122、在谈Java的流类之前，先谈如何生成一个File对象，它时一个和流无关的类。File对象可用来生成
和文件（及其所在的路径）或目录结构相关的对象，由于不同的系统可能会有不同的目录结果表示法，使
用File可完成和系统无关的目的（使用抽象的路径表示法）。
123、File对象生成方法：
File(String path):将一个代表路径的字符串转换为抽象的路径表示法
File(String parent,String child):parent代表目录，child代表文件，child不可为空
File(File parent,String child):parent代表一个File对象的目录，child代表文件，child不可为空
124、File提供一些方法来测试或检查一个File对象：
boolean exists():若该文件或目录存在，则返回true
boolean isDirectory():若为目录则返回true
File[] listFiles():得到该对象所代表的目录下的File对象数组，若不为该目录，则返回null
String[] list():同上，但返回一个String数组
long length():得到和该对象相关的文件的大小，若不存在，则返回值为0L
String toString():得到抽象路径表示法
String getParent():得到抽象路径表示法的目录部分（不包含最后一个部分）
String getName():得到抽象路径表示法的最后一个部分
125、改变一个File对象的方法：
boolean renameTo(File newName):将目前File对象所代表的路径名改为newName所代表的路径名
。若更改成功，则返回值为true
boolean mkdir():生成一个新的目录。入成功，则返回值为true
boolean mkdirs():生成一个新的目录，包含不存在的子目录。若成功，返回值为true
boolean delete():删除目前File对象所代表的文件或目录，若是目录，则需为空的。若成功，
返回true
126、没有参数的listFiles()会列出所有的文件名。使用File[] listFiles(FilenameFilter filter)过
滤某些特殊的扩展名或包含某些字符的文件名。FilenameFilter是一个接口，必须生成一个实现它的类来
负责过滤文件名，该类需取代FilenameFilter惟一的方法accept()。boolean accept(File dir,String
name),若返回为true则会将目前检查的文件包含在listFiles()的返回数组内。
127、字节流的构造函数：
FileInputStream(String name):打开文件name用以读取数据
FileInputStream(File file):打开和File对象file相关联的文件，用以读取数据
FileOutputStream(String name):打开文件name用以写入数据
FileOutputStream(File file):打开和File对象file相关联的文件，用以写入数据
FileOutputStream(String name,boolean append):打开文件name用以写入数据，若append为true，则写入的数据会加到原有的文件后。
128、字节数组（byte array）的构造函数：
ByteArrayInputStream(byte[] buffer):生成一个字节数组的输入流，并指定一个字节数组
buffer为此输入流的流缓冲区。
ByteArrayOutputStream():生成一个字节数组的输出流，其缓冲区的默认初始大小为32字节，若
有需要，缓冲区的大小会随之增加
ByteArrayOutputStream(int size):同上，但分配size字节的初始大小给缓冲区。
129、一些ByteArrayOutStream常用的方法：
int size():返回此流缓冲区的大小
byte[] toByteArray():生成一个新的字节数组，并将流的内容复制到此自己数组。
String toString():将流的内容转换为String对象。
130、文件的合并：SequenceInputStream
SequenceInputStream(InputStream head,InputStream tail):生成一个新的输入流，先读入head，后是tail
SequenceInputStream(Enumeration enum):将enum内的流根据序合并韦一个新的输入流，enum内必须是InputStream对象。
131、Vector的功能就像一个数组，但它能根据需要来改变大小。
132、管道（pipe）提供一种线程间通信的方法，可由于IPC（Inter-Process Communication，进程间通
信）或是ITC（Inter-Thread Communication，线程间通信），但它无法执行不同主机之间的通信。
133、一个输入管道是用来接收一个输出管道所写出的数据，因此，一个线程会负责送出
（PipedOutputStream对象）数据，而另一个线程需负责接收（PipedInputStream对象）这些数据。
134、管道的数据流（data flow）是单向的，需要生成另一组输入和输出管道来负责另一个方向的数据传
送。
135、如果要将管道输出流的数据送到管道输入流，可使用
PipedOutputStream(PipedInputStream pipeIn)或
connect(PipedInputStream pipeIn)
140、字符流的类：1），BufferedReader是一种过滤器（filter）（extends FilterReader）。过滤器用
来将流的数据加以处理再输出。构造函数为：
BufferedReader(Reader in):生成一个缓冲的字符输入流，in为一个读取器
BufferedReader(Reader in,int size):生成一个缓冲的字符输入流，并指定缓冲区的大小为size
常用的方法为：
String readLine():读入一行的文字（以\n或\r结尾），返回的String对象并不包含\n或\r，若已达流的末端则返回null
当使用缓冲流的read()或readLine()读取数据时，先会尝试从缓冲区读取，若缓冲区中并没有数
据，则会尽可能的将数据读入缓冲区中，以留待后续的读取。
141、2），LineNumberReader也是一种过滤器，而它也是一种缓冲流（extends BufferedReader），可用
来记录读入的行数，这里所谓的一行时以\n或\r结尾。常用方法：
int getLineNumber():得到目前的行数。
142、3），PrinterWriter也是一种过滤器（extendes FilterWriter）,可用来将输出导入某种设备。
143、I/O流的一个特点是它们能经过流链接的方式结合在一起，每个流类会执行特殊的工作再将结果传到
下一个链接，可使用过滤器将流链接在一起。
BufferedReader inBuffer=new BufferedReader(new FileReader(inFile));
使用流链接时，只需要关闭最外层的链接流，其他链接的流会自动关闭。可以使用的链接是最后一个流（
inBuffer），此时，我们并无法直接使用FileReader流。如果写成：
FileReader fileIn=new FileReader(inFile);
BufferedReader inBuffer=new BufferedReader(fileIn);
此时，fileIn仍存在，这可能会因写程序的疏忽而造成同时有两个流链接导同一个来源（inFile），这往
往会有潜在的危险。
144、随机存取：RandomAccessFile,构造函数
RandomAccessFile(File file,String mode):其中mode是用来指定存取的模式，可为r，w或rw
RandomAccessFile(String name,String mode):name为和系统相关的文件名字
常用方法：
读取：boolean readBoolean();byte readByte();char readChar();double readDouble
();float readFloat();int readInt();long readLong();short readShort();String readLine()
写入：void writeByte(Byte v);void writeByte(String s);void writeChar(char v);void
writeChars(String s);void writeDouble(double v);void writeFloat(float v);void writeInt(int
v);void writeLong(long v);void writeShort(short v)
与目前文件位置有关的方法：
void seek(long pos):将文件指针移到pos（不可为负）的位置这是相对于文件初始位置的值（初始值为0）
long getFilePointer():得到目前文件指针的位置。
long length():得到文件的长度
145、文件压缩及解压缩方法：ZipInputStream(extends InflaterInputStream)和ZipOutputStream
(extends DeflaterOutputStream)
146、将文件写入ZIP文件的步骤：
1）生成和所要生成的ZIP文件相关联的ZipOutputStream对象
2）一个ZIP文件往往不只含有一个压缩文件，我们将每个要加入的文件称为一个ZIP入口，我们
使用ZipEntry(String fileName)来生成这些ZipEntry对象。
3）使用putNextEntry(ZipEntry entry)将此ZIP入口加入ZIP文件
4）将文件内容写入此ZIP文件
5）使用closeEntry()结束目前的ZIP入口，继续下一个ZIP入口
147、将压缩文件从ZIP文件读出的步骤：
1）生成和所要读入的ZIP文件相关联的ZipInputStream对象
2）利用getNextEntry()得到下一个ZIP入口
148、我们将对象存取自一个流称为序列化（serialization），为了完成对象的序列化（将一个对象写导
流称为序列化（serializing），而从一个流将对象读出称为反序列化（deserializing））。
149、存取的对象需满足下列条件：
类需为public
类需实现Serializable接口
若有数据不是可序列化的或不需要写出，则需将其声明为transient
150、java.io提供ObjectInputStream和ObjectOutputStream来存取对象，由于它们和DataInputStream及
DataOutputStream有共同的接口，因此它们也可使用相同的方法来读取或写入数据。还有其他的方法：
void writeObject(Object obj):用于ObjectOutputStream，将对象写入流
Object readObject():用于ObjectInputStream，将对象由流读出。