串的最后几个字符呢？
查了一下资料和api，觉得可以用两种方法：
法一：
用循环直到结束，这样取得字符串的长度，然后再从长度往前取；
法二：
先取得前面的子串，然后再用replace方法；例如：
  String s1="abcde";
  String s2="abc";
  String s3="";
  s3=s1.replace(s2,"");
  System.out.println(s3);//s3="de";

哈哈，自己真是太笨了，其实so easy！：
String subs = s.substring((s.length()-5),s.length());

启发资料：
JavaScript 中如何取得一串字符串除后5个的其人全部
http://topic.csdn.net/t/20060110/15/4508133.html

String subs   =   s.substring(0,s.length-5);

最近为了计算文档间的相关性需要用到对数的计算，在网上找到下面的方法：
其中的关键是：1 java标准包提供了自然对数的计算方法，2 其他的对数计算可

以转换为自然对数的计算。

下面是转贴：但不知道谁是原创作者。
后来搜索到这个连接：
还是人家有专业精神：
下面是他的描述：
 Java supplies a function to calculate natural logs, base e =

2.718281828459045. To calculate logs to other bases, you need to

multiply by a fixed constant: for a log base b multiply by 1/logeb

　　Sun的J2SE提供了一个计算自然对数方法——double java.lang.Math.log

(double)。请看如下代码：
　　double x = Math.log(5);
　　等价于下面的数学方程：
　　x = ln 5
　　或
　　x = loge5
　　其中e是内皮尔数或自然数。

　　如果你想算底不同的对数又该如何做呢？很遗憾，我们还没有办法计算以10

为底或以2为底的对数。
    但是它们却是在计算对数时用的最多的。
    要想解决这个问题，我们就要回想曾经在学校里学过的数学和对数方程：
　　logx(y) =loge(x) / loge(y)
　　这只需一段简单的Java程序来实现：
　　public class Logarithm {
　　     static public double log(double value, double base) {
    　　 return Math.log(value) / Math.log(base);
　　     }
　　}
　　计算100的以10为底的对数就变为非常简单了：
　　double log = Logarithm.log(100, 10); // log is 2.0
　　512的以2为底的对数是：
　　double log = Logarithm.log(512, 2); // log is 9.0
　　下面的两个简单的方法也都是很有用的：
　　static public double log2(double value) {
　　 return log(value, 2.0);
　　 }
　　 static public double log10(double value) {
　　 return log(value, 10.0);
　　 }

问题：

ClassLoader主要用于加载类文件，利用反射（newInstance())生成类实例等，那么它可以用于加载xml、txt文件等吗？

解答：

可以。只是它与java.io相比，定位的初始路径不同；当然各自的功能也各有侧重，java.io侧重于与磁盘文件打交道，而ClassLoader侧重于与.class文件打交道；java.io更适合于纯java project，而ClassLoader更适合于web project。

详细见前面写的“java读取文件的两种方法：java.io和java.lang.ClassLoader”一文。

URI、URL和URN之间的区别与联系

String int Integer间的转换

一 填充：

Arrays.fill( type[] a, type val) 系列方法是给，数组填充。就是简单的把一个数组全部或者某段数据填成一个特殊的值。

二 查找：

binarySearch(type[] a, type key) 系列方法是，在某类型的数组中用2分法查找特定的Key的元素，返回元素号。前提是这个数组是经过排序的，如果有多个元素和Key值相等的情况下，无法预料，返回的是哪一个。对于返回值，有以下规律，返回值 < 0表示没有找到，返回值 >= 0说明找到了。

对于插入，Arrays没有特殊算法，一般对数组的插入都是转化为 Collection 之后再做的，但是binarySearch还是能帮你找到数组的插入点的，插入点位置为返回值的绝对值减1( | 返回值 | - 1 ) 。

对排序过的数组查找，算法用 2 分法已经相当快了，呵呵。

三 比较:

equals(type[] a, type[] b) 系列方法是做两个数组的比较的，相等返回true。这个方法运用的时候，有些地方要注意。
比较两个float数组的时候，对每个元素比较，程序不是用的==来判断的，而是用new Float(f1).equals(new Float(f2))，这个方法认为 NaN 等于它本身，0.0f不等于-0.0f。对于double数组也是一样的。

对于Object[]数组呢，是用的(e1==null ? e2==null : e1.equals(e2))。

四 排序:

sort(type[] a) 系列方法是对数组排序的。Sun用的排序算法是调整快速排序法,采用的是Jon L. Bentley and M. Douglas McIlroy's "Engineering a Sort Function", Software-Practice and Experience, Vol. 23(11) P. 1249-1265 (November 1993)。这个算法排序要n* O(n)时间的大量数据，只需要O(n1ogn)时间。

关于快速排序法参考：(http://algorithm.myrice.com/algorithm/commonalg/sort/internal_sorting/quick_sort/quick_sort.ht m
快速排序 Quick Sort

我们已经知道， 在决策树计算模型下，任何一个基于比较来确定两个元素相对位置的排序算法需要 Ω(nlogn) 计算时间 。如果我们能设计一个需要 O(n1ogn) 时间的排序算法，则在渐近的意义上，这个排序算法就是最优的。许多排序算法都是追求这个目标。快速排序算法它在平均情况下需要 O(nlogn) 时间。这个算法是由 C.A.R.Hoare 发明的。 )

五 数组的转换:

用 Arrays.asList(Object[] a) 能够实现数组到 ArrayList 的转换。同时利用 Collection.toArray() 能将一些集合类型的数据方便的变成数组。

了解到在Java中数组是一个对象，而使用=指定时是将对象指定给数组名来引用，而不是将数组进行复制。如果想将整个数组的值复制给另一个数组该如何作呢？可以使用循环，将整个数组的元素值遍历一遍，并指定给另一个数组相对应的索引位置。范例5.10示范了进行数组复制的方法。

public class ArrayCopy {

    public static void main(String[] args) {

        int[] arr1 = {1, 2, 3, 4, 5};

        int[] arr2 = new int[5];

        for(int i = 0; i < arr1.length; i++)

            arr2[i] = arr1[i];

        for(int i = 0; i < arr2.length; i++)

            System.out.print(arr2[i] + " ");

        System.out.println();

执行结果：

另一个进行数组复制的方法是使用System类提供的arraycopy()方法。其语法如下：

System.arraycopy(来源, 起始索引, 目的, 起始索引, 复制长度);

范例5.11改写了范例5.10，使用System.arraycopy()进行数组复制，执行结果与范例5.10是相同的。

public class ArrayCopy2 {

    public static void main(String[] args) {

        int[] arr1 = {1, 2, 3, 4, 5};

        int[] arr2 = new int[5];

        System.arraycopy(arr1, 0, arr2, 0, arr1.length);

        for(int i = 0; i < arr2.length; i++)

            System.out.print(arr2[i] + " ");

        System.out.println();

    }

return语句是用来退出方法的跳转语句：

只要遇到return语句，方法就在那一行代码停止执行，执行控制将立刻返回到调用该方法的代码处。

          对于返回值类型为void的方法，return关键字单独作为完整的语句使用：

然而，对于返回类型为void的方法，return;语句是可选的。如果省略这条语句，隐含表明方法的最后一行有一个return;语句。即，下面两个版本的doSomething方法是等价的：

和

另一方面，对于返回类型非void的方法体，必须至少包括一条明确的return语句。这种情况下，return关键字后面必须跟随一个求值类型和方法声明的返回类型一致的表达式。例如，如果方法定义为具有int返回类型，那么下列任何一种return语句都可以接受：

等等。另一个例子，如果方法定义为具有boolean返回类型，那么下列任何一种return语句都可以接受：

方法体可以包含不只一条return语句。但好的编程习惯是一个方法中只在最末尾包含一条return语句。再看一下前面讨论过的isHornorsStudent方法，这个方法有两条return语句：

使用局部boolean变量result来重写这个方法，该变量捕获最终返回的true/false结果。在方法最末尾用一条return语句返回result变量的值：

如上述代码所示，由于已经给result变量赋予初值false，因此在else子句中明确地给它赋值false是不必要的，可以像下面这样简化isHornorsStudent方法：

但是有一种情况下多个return语句是可以接受的：方法需要执行一系列操作，在这个过程中，任何一步失败意味着整个方法失败。下面的伪代码阐明了这种情况：

          注意，Java编译器会校验是否方法的所有逻辑路径都返回类型正确的结果。例如，下面的方法会产生编译错误，因为只有在if测试成功时才能到达return语句，如果if测试失败，则return语句被绕过：

这种情况下将产生下面这个编译错误：

File,FileInputStream,FileReader,InputStreamReader,BufferedReader 的使用和区别

参考资料：

l         《 core java 》 12 章

l         使用 Java 操作文本文件的方法详解

http://java.ccidnet.com/art/3737/20041108/523627_1.html

l  FileReader 是什么类？和 FileInputStream 有什么不同？？？      

 http://book.hackbase.com/ask2/ask107572.htm
自己的整理和领会：
引言：
    
C语言只需要一个File*就可以了，与C不同，java有一系列流类型，其数量超过60种。类库的设计者声称：“有

足够的理由为用户提供丰富的流类型的选择：这样做可以减少程序的错误。”例如，在C语言种，许多人认为“

将输出流写入一个只读模式的文件”是很常见的错误。（事实上，这并不常见。）

我们认为在C＋＋语言中，流接口设计者避免程序出错的主要“工具”是小心谨慎的态度，在java语言中更是如

此。流库的高度复杂性迫使程序设计人员谨小慎微。
    
1.  File类
  
1 ） File 类介绍（《 core java 》 638 页）

File 类封装了对用户机器的文件系统进行操作的功能。例如，可以用 File 类获得文件上次修改的时间移动，

或者对文件进行删除、重命名。换句话说，流类关注的是文件内容，而 File 类关注的是文件在磁盘上的存储

。

File 类的主要方法有： getName(),getCanonicalFile(),lastModified(),isDerector(),isFile(),getPath()

等；

2 ） File 类与 FileInputStream 类的区别：

流类关注的是文件内容，而 File 类关注的是文件在磁盘上的存储。

File 不属于文件流 , 只能代表一个文件或是目录的路径名而已。

提示：（《 core java 》 639 页）

如果处理文件或者目录名，就应该使用 File 对象，而不是字符串。例如， File 类的 equals 方法知道一些

文件系统对大小写是敏感的，目录尾的“ / ”字符无关紧要。

自己的领会：

FileInputStream 类或者 FileReader 类的构造函数有多个，其中典型的两个分别为：一个使用 File 对象为

参数；而另一个使用表示路径的 String 对象作为参数；自己以前一直觉得直接用了 String 指定路径就可以

了，一直不明白为什么很多人都先构造一个 File 对象，现在终于明白了，“如果处理文件或者目录名，就应

该使用 File 对象，而不是字符串。”！

2.       FileInputStream 类

1 ） FileInputStream 类介绍：

以字节为单位（非 unicode ）的流处理。字节序列即：二进制数据。与编码无关，不存在乱码问题。

FileInputStream 类的主要方法有：

Read （）， read （ byte[] b ）， read （ byte[],int off,int len ） ,available();

2 ） FileInputStream 类与 FileReader 类的区别：

两个类的构造函数的形式和参数都是相同的，参数为 File 对象或者表示路径的 String ，它们到底有何区别

呢？

l         Readers and Writers work only on line based character data, so plain text files.
For anything else, you MUST use Streams.

l         JDK5 API:

FileInputStream is meant for reading streams of raw bytes such as image data. For reading streams

of characters, consider using FileReader.

FileReader is meant for reading streams of characters. For reading streams of raw bytes, consider

using a FileInputStream .

l         FileInputStream ：以字节流方式读取； FileReader ：把文件转换为字符流读入；
l        InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。用Reader读取出

来的是char数组或者String ，使用InputStream读取出来的是byte数组。
l        Reader类及其子类提供的字符流的读取char（16位,unicode编码），inputStream及其子类提供字节

流的读取byte（8位），所以FileReader类是将文件按字符流的方式读取，FileInputStream则按字节流的方式

读取文件；InputStreamReader可以将读如stream转换成字符流方式，是reader和stream之间的桥梁
l  最初Java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类。
  
l         FileInputStream 类以二进制输入 / 输出， I/O 速度快且效率搞，但是它的 read （）方法读到

的是一个字节（二进制数据），很不利于人们阅读。

l         而 FileReader 类弥补了这个缺陷，可以以文本格式输入 / 输出，非常方便；比如可以使用

while((ch = filereader.read())!=-1 ) 循环来读取文件；可以使用 BufferedReader 的 readLine() 方法一

行一行的读取文本。

l         当我们读写文本文件的时候，采用 Reader 是非常方便的，比如 FileReader ，

InputStreamReader 和 BufferedReader 。其中最重要的类是 InputStreamReader ，它是字节转换为字符的桥

梁。 你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如 GBK 等

。

l         FileReader 与 InputStreamReader 涉及编码转换 ( 指定编码方式或者采用 os 默认编码 ) ，可

能在不同的平台上出现乱码现象！而 FileInputStream 以二进制方式处理，不会出现乱码现象 .

3 ）自己的领会：

l         如果处理纯文本文件，建议使用 FileReader ，因为更方便，也更适合阅读；但是要注意编码问题

！
l   其他情况（处理非纯文本文件），FileInputStream是唯一的选择；FileInputStream是进Socket通讯时会

用到很多，如将文件流是Stream的方式传向服务器！
  
3.       FileReader 类

1）    FileReader 类介绍：

InputStreamReader 类的子类，所有方法（ read （）等）都从父类 InputStreamReader 中继承而来；

2）    与 InputStreamReader 类的区别：

l         自己的领会：

该类与它的父类 InputStreamReader 的主要不同在于构造函数，主要区别也就在于构造函数！从

InputStreamReader 的构造函数中看到，参数为 InputStream 和编码方式，可以看出，当要指定编码方式时，

必须使用 InputStreamReader 类；而 FileReader 构造函数的参数与 FileInputStream 同，为 File 对象或

表示 path 的 String ，可以看出，当要根据 File 对象或者 String 读取一个文件时，用 FileReader ；我

想 FileReader 子类的作用也就在于这个小分工吧。

3）    一般用法：

FileReader fr = new FileReader("ming.txt");
　　 char[] buffer = new char[1024];
　　 int ch = 0;
　　 while((ch = fr.read())!=-1 )
　　 {
　　　 System.out.print((char)ch);
　　 }

4.       InputStreamReader 类

l         以文本格式输入 / 输出，可以指定编码格式；

l         主要方法：

getEncoding ()，read();

l         一般用法：

InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt"));
　　 while((ch = isr.read())!=-1)
　　 {
　　　 System.out.print((char)ch);
　　 }

5.       BufferedReader 类

l         Jdk5 api ：

Read text from a character-input stream, buffering characters so as to provide for the efficient

reading of characters, arrays, and lines.
l    BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，

读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。
l  一般用法：
    
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
　　String data = null;
　　while((data = br.readLine())!=null)
　　{
　　　System.out.println(data);
　　}
    
  
6.       总结以上内容，得出比较好的规范用法：

1）    File file = new File ("hello.txt");

FileInputStream in=new FileInputStream(file);

2）    File file = new File ("hello.txt");

FileInputStream in=new FileInputStream(file);

InputStreamReader inReader=new InputStreamReader(in);

BufferedReader bufReader=new BufferedReader(inReader);

3）    File file = new File ("hello.txt");

FileReader fileReader=new FileReader(file);

BufferedReader bufReader=new BufferedReader(fileReader);

7.一些写法的区别：
1）
File file = new File ("hello.txt");
FileInputStream in=new FileInputStream(file);
InputStreamReader inReader=new InputStreamReader(in);
BufferedReader bufReader=new BufferedReader(inReader);

2）
FileInputStream in＝null;
File file = new File ("hello.txt");
in=new FileInputStream(file);
BufferedReader bufReader=new BufferedReader(new InputStreamReader(in));

3）
File file = new File ("hello.txt");
BufferedReader bufReader=new BufferedReader(new InputStreamReader(new FileInputStream(file)));

上述两种写法的微小区别：
a）第二种方式中把“FileInputStream in＝null;”定义单独放在开始处，说明下面应该还有要用到in对象变量的地方；（BufferedReader处用了）

b）第二种方式没有定义InputStreamReader的对象变量，直接在BufferedReader的构造函数中new一个，
这种方式与第一种方式的主要区别：InputStreamReader对象只使用一次！

这对于在这里只需要使用一次这个InputStreamReader对象的应用来说更好；无需定义InputStreamReader的对象变量，接收由new返回的该对象的引用，因为下面的程序中不需要这个InputStreamReader的对象变量，所以无需定义；所以这种情况下，第二种方式比第一种更好一些。

c）第三种方式中，典型的三层嵌套委派关系，清晰看出Reader的委派模式（《corejava》12章有图描述该委派关系），FileInputStream和InputStreamReader都没有定义变量，new生成的对象都只是使用一次。

d）三种方式的区别也就在于FileInputStream和InputStreamReader对象是否都只使用一次，是否需要定义它们的对象变量，以及个人的编码习惯。

e)但是要注意异常处理，FileInputStream(file)会抛出NotFileFoundException，如果采用surround方式
（try&catch）处理，应该用第二种方式，这样可以用System.out.println提示文件未找到；
当然在函数名后使用throws Exception，然后用第三种方式也行，但似乎这适合有用户界面的情况，把异常抛出在客户端在处理。

了解。其实应该说是自己以为了解了，但是找实习时，笔试才知道，面对这些基本得不能再基本的题目，

自己却答不出来，猛然发觉，原来是自己根本就还没有理解透彻！！！

一、先用自己的语言概括一下“多态性”吧：

多态性是指在继承层次或者接口与实现类层次上，如果子类覆盖了父类的方法，或者说实现类实现了接口

定义的方法，那么可以通过一般化的用父类或者接口来调用该方法，JVM在运行期能够根据实际传递的子

类对象引用，来调用相应的方法，产生正确的行为。达到“同一函数，不同行为”的效果。java的多态性

是通过动态绑定实现的。

例如，类A中有一aa()方法，类B和类C继承类A，并覆盖了类A的aa()方法，这时在程序中，如果用类A的引

用a调用aa方法：a.aa()，JVM会根据动态绑定机制，根据a的实际类型调用相应方法；如果a=new B(),那

么调的是B的方法；如果a=new C(),那么调的是C的方法。

二、上述概念包含几个关键点：
首先是多态性的前提：
1.在继承层次或者接口与实现类层次上才有多态性；
2.子类覆盖了父类的方法，或者实现类实现了接口定义的方法，才有多态性；

其次是多态性的表现：
1.可以通过一般化的用父类或者接口来调用某一方法，JVM在运行期能够根据实际传递的子类对象引用，

来调用相应的方法，从而产生正确的行为。

最后是多态性的实现原理：
1.java多态性是通过函数的动态绑定机制实现的；

至于动态绑定的机制是什么，请看下一篇文章“java动态绑定机制”。

有待查看的资料：
1.C++的书；（java的书中只对多态性进行阐述，但是很少对多态性的概念作出解释，好像C++中的书中有

概念）

2.《core java》

参考资料：
1.简单的理解 类的继承 和 多态性
http://bbs.nou.com.cn/thread-93841-1-1.html

2.JAVA中动态性实例解释
http://dev.csdn.net/article/12/12550.shtm

c:\program files\java\jre 下，一套自己选择的 jdk 安装路径下，一般为

d:\jdk1.5\jre ；）

答：

1.1 以下是 java.sun.com 上的官方解释：

Question: Why would anyone want the JRE if the Java 2 SDK has

everything in the JRE and more?

Answer: The JRE is smaller and therefore easier to download or

distribute with software than the Java 2 SDK. Most users of Java

technology are people who just want to run applets and applications

developed by others. They're not interested in developing any

applications themselves. The relatively small Java RE is made for such

end users. They can download the Java RE themselves from the web, or

software vendors can include it in their own products. The typical end

-user doesn't need the bulkier Java 2 SDK with its development tools.

1.2

自己的理解：

问： jre 和 jdk 有什么区别 ?

答：

JRE 提供了 JAVA 程序运行的必要环境平台；

jdk 提供了 java 的编程环境，它包含编译调试的环境功能，包含 JRE ；

如果只安装了 jre ，那么 cmd 命令行中只能执行 java 指令，不能执行 javac ；

安装好 jdk 后才能执行 javac ，因为 jre 中不包含用于开发的编译环境；

问：

为什么安装 jdk 后会有两套 jre ？

答：

l         之所以需要两套 jre ，是因为可以分担工作；当用户只需要执行 java 的程序时，那

l 么 c:\program files\java\jre 下的 jre 就 ok ！当用户是 java 程序员，需要 java 开发环境，那么开发时，系统就会优先去找“ java 、 javac ”这些命令本身的目录或者他们的父目录的 jre ；这样开发时一般运行的是 jdk 下的 jre ；而运行外部程序时，一般运行的是

l c:\program files\ 下的 jre ，实现了分工，不同的 jre 负责各自范围的内容；

l         详细的解释和学习，参看王森的 <<java 深度历险 >> 的第二章“深入 java 2 SDK ”

l ，讲得非常明白到位！

相关内容摘录如下：（图略）

您所執行的是哪一個 java.exe ?

既然您的電腦裡頭至少有兩套 JRE ，那麼誰來決定用哪一套 JRE 呢 ? 這個重

責大任就落在 java.exe 的身上。

當我們在命令列輸入

java XXX

的時候， java.exe 的工作就是找到合適的 JRE 來執行類 別 檔。 java.exe 依照底

下邏輯來尋找 JRE:

1. 自己的目錄下有 沒 有 JRE 目錄。 ( 這個部分這樣 說 並不是非常精確，原因

請詳見 JDK 原始碼，這此不特 別說 明 )

2. 父目錄底下 JRE 子目錄。

3. 查詢 Windows

Registry( HKEY_LOCAL_MACHINE\Software\JavaSoft\Java

Runtime Environment\ ) 。

所以， java.exe 的執行結果和您電腦裡面哪一個 java.exe 被執行，然後哪一

套 JRE 被拿來執行 Java 應用程式有莫大的關係。

l         另外，在实际的项目开发中，我们发现很多时候 eclipse 老报错，提示 java 虚拟机

l 内存不足，但是机器的内存是 2G 的，怎么可能内存不足呢？后来发现是 jvm 所支持

l 的内存最高只能设置为 64M 的缘故，这时我们把一套 jre 拷贝到 eclipse 的目录下，让 eclipse 单独跑一套 jre ，多个 jvm 分管工作， jvm 内存不足的问题就解决了。

二、 jdk 下的 lib 与 jre 下的 lib 有何区别？

自己的理解：

jdk 下的 lib 包括 java 开发环境的 jar 包， jre 下的 lib 只是运行 java 程序的 jar 包；