java学习笔记,很多tips

来源：互联网发布：世界最成功的网络银行编辑：程序博客网时间：2024/04/28 05:59

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，将对象由流读出。