广州中国科学院软件应用技术研究所笔经

ゞ浴缸里的玫瑰 2022-10-01 01:58 124阅读 0赞

首当其冲，一个java的基础知识，掌握的不明确。String/StringBuffer/StringBuilder的区别  
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#

String:

是对象不是原始类型。  
         String为不可变对象，一旦被创建,就不能修改它的值。  
        对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去。

String是final类,即不能被继承。

StringBuffer:   
         是一个可变对象，当对他进行修改的时候不会像String那样重新建立对象  
        它只能通过构造函数来建立，  
        StringBuffer sb = new StringBuffer();  
        但是注意，不能通过付值符号对他进行赋值。  
        sb = "welcome to here!";//error

对象被建立以后,在内存中就会分配内存空间,并初始保存一个null。

向StringBuffer中赋值的时候可以通过它的append方法。

sb.append("hello");  
        字符串连接操作中StringBuffer的效率要比String高。  
  
        String str = new String("welcome to ");  
        str += "here";

上面语句的处理步骤实际上是通过建立一个StringBuffer，然后调用append()，

最后再将StringBuffer toSting()，

这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣。

并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值。

这样原来的对象就没用了，就要被垃圾回收.这也是要影响性能的。

StringBuffer维护了一个**大小固定**的字符串缓冲区，当字符串长度超过StringBuffer大小时会自动增加，

主要使用Insert和append方法，对于运行期要进行字符串的组装操作推荐使用。

**StringBuilder:**

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。也就是说，StringBuffer是线程安全的，StringBuilder不是线程安全的。StringBuilder类被设计用作 StringBuffer 的一个简易替换，

用在字符串缓冲区被单个线程使用的时候。

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#

第二个，Stack与Heap的区别

java中使用new关键字 创建的对象都是存放在heap中的。

在JVM中，内存分为两个部分，Stack（栈）和Heap（堆），这里，我们从JVM的内存管理原理的角度来认识Stack和Heap，并通过这些原理认清Java中静态方法和静态属性的问题。  
        一般，JVM的内存分为两部分：Stack和Heap。  
        Stack（栈）是JVM的内存指令区。Stack管理很简单，push一定长度字节的数据或者指令，Stack指针压栈相应的字节位移；pop一定字节长度数据或者指令，Stack指针弹栈。Stack的速度很快，管理很简单，并且每次操作的数据或者指令字节长度是已知的。所以Java 基本数据类型，Java 指令代码，常量都保存在Stack中。

Heap（堆）是JVM的内存数据区。Heap 的管理很复杂，每次分配不定长的内存空间，专门用来保存对象的实例。在Heap 中分配一定的内存来保存对象实例，实际上也只是保存对象实例的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法（方法是指令，保存在Stack中）,在Heap 中分配一定的内存保存对象实例和对象的序列化比较类似。而对象实例在Heap 中分配好以后，需要在Stack中保存一个4字节的Heap 内存地址，用来定位该对象实例在Heap 中的位置，便于找到该对象实例。

由于Stack的内存管理是顺序分配的，而且定长，不存在内存回收问题；而Heap 则是随机分配内存，不定长度，存在内存分配和回收的问题；因此在JVM中另有一个GC进程，定期扫描Heap ，它根据Stack中保存的4字节对象地址扫描Heap ，定位Heap 中这些对象，进行一些优化（例如合并空闲内存块什么的），并且假设Heap 中没有扫描到的区域都是空闲的，统统refresh（实际上是把Stack中丢失了对象地址的无用对象清除了），这就是垃圾收集的过程。

JVM的体系结构  
        我们首先要搞清楚的是什么是数据以及什么是指令。然后要搞清楚对象的方法和对象的属性分别保存在哪里。  
        1）方法本身是指令的操作码部分，保存在Stack中；  
        2）方法内部变量作为指令的操作数部分，跟在指令的操作码之后，保存在Stack中（实际上是简单类型保存在Stack中，对象类型在Stack中保存地址，在Heap 中保存值）；上述的指令操作码和指令操作数构成了完整的Java 指令。  
        3）对象实例包括其属性值作为数据，保存在数据区Heap 中。  
        非静态的对象属性作为对象实例的一部分保存在Heap 中，而对象实例必须通过Stack中保存的地址指针才能访问到。因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针。  
        非静态方法和静态方法的区别：  
        非静态方法有一个和静态方法很重大的不同：非静态方法有一个隐含的传入参数，该参数是JVM给它的，和我们怎么写代码无关，这个隐含的参数就是对象实例在Stack中的地址指针。因此非静态方法（在Stack中的指令代码）总是可以找到自己的专用数据（在Heap 中的对象属性值）。当然非静态方法也必须获得该隐含参数，因此非静态方法在调用前，必须先new一个对象实例，获得Stack中的地址指针，否则JVM将无法将隐含参数传给非静态方法。  
静态方法无此隐含参数，因此也不需要new对象，只要class文件被ClassLoader load进入JVM的Stack，该静态方法即可被调用。当然此时静态方法是存取不到Heap 中的对象属性的。  
        总结一下该过程：当一个class文件被ClassLoader load进入JVM后，方法指令保存在Stack中，此时Heap 区没有数据。然后程序技术器开始执行指令，如果是静态方法，直接依次执行指令代码，当然此时指令代码是不能访问Heap 数据区的；如果是非静态方法，由于隐含参数没有值，会报错。因此在非静态方法执行前，要先new对象，在Heap 中分配数据，并把Stack中的地址指针交给非静态方法，这样程序技术器依次执行指令，而指令代码此时能够访问到Heap 数据区了。

静态属性和动态属性：  
        前面提到对象实例以及动态属性都是保存在Heap 中的，而Heap 必须通过Stack中的地址指针才能够被指令（类的方法）访问到。因此可以推断出：静态属性是保存在Stack中的，而不同于动态属性保存在Heap 中。正因为都是在Stack中，而Stack中指令和数据都是定长的，因此很容易算出偏移量，也因此不管什么指令（类的方法），都可以访问到类的静态属性。也正因为静态属性被保存在Stack中，所以具有了全局属性。  
        在JVM中，静态属性保存在Stack指令内存区，动态属性保存在Heap数据内存区。

zoer-from：http://www.i5a6.com/?p=661

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
第三个：java四舍五入方法：

方法好像很多，能实现就好。

public static void main(String[] args) {
    		double d = 1.15454;
    		double dd = Math.round(d * 10) / 10.00;
    		double ddd = Math.round(d * 100) / 100.00;
    		System.out.println(dd);
    		System.out.println(ddd);
    }

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#异常类的继承关系：

之前只是知道用异常类，但是从来没有关注过异常类之间的继承关系。

## java.lang   类 Throwable ##

java.lang.Object
      --java.lang.Throwable

**所有已实现的接口：**

\--Serializable

**直接已知子类：**

\--Error, Exception

在Java语言以前，代表各种异常情况一般使用数字，例如常见的浏览器中的404错误，以及Windows中的错误编号等，使用这些数字可以代表各种异常情况，但是最大的不足在于这些数字不够直观，无法很直接的从这些数字中知道异常出现的原因。  
所以在Java语言中代表异常时，不再使用数字来代表各种异常的情况，而是使用一个专门的类来代表一种特定的异常情况，在系统中传递的异常情况就是该类的对象，所有代表异常的类组成的体系就是Java语言中的异常类体系。  
为了方便对于这些可传递对象的管理，Java API中专门设计了java.lang.Throwable类，只有该类子类的对象才可以在系统的异常传递体系中进行。该类的两个子类分别是：  
1、Error类  
该类代表错误，指程序无法恢复的异常情况。对于所有错误类型以及其子类，都不要求程序进行处理。常见的Error类例如内存溢出StackOverflowError等。  
2、Exception类  
该类代表异常，指程序有可能恢复的异常情况。该类就是整个Java语言异常类体系中的父类。使用该类，可以代表所有异常的情况。  
在Java API中，声明了几百个Exception的子类分别来代表各种各样的常见异常情况，这些类根据需要代表的情况位于不同的包中，这些类的类名均以 Exception作为类名的后缀。如果遇到的异常情况，Java API中没有对应的异常类进行代表，也可以声明新的异常类来代表特定的情况。  
在这些（Exception）异常类中，根据是否是程序自身导致的异常，将所有的异常类分为两种：  
**1、RuntimeException及其所有子类**   
该类异常属于程序运行时异常，也就是由于程序自身的问题导致产生的异常，例如数组下标越界异常ArrayIndexOutOfBoundsException等。  
该类异常在语法上不强制程序员必须处理，即使不处理这样的异常也不会出现语法错误。  
**2、其它Exception子类**   
该类异常属于程序外部的问题引起的异常，也就是由于程序运行时某些外部问题导致产生的异常，例如文件不存在异常FileNotFoundException等。  
该类异常在语法上强制程序员必须进行处理，如果不进行处理则会出现语法错误。  
熟悉异常类的分类，将有助于后续语法中的处理，也使得在使用异常类时可以选择恰当的异常类类型。  
 \#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#

jsp内置对象都有哪些？作用是什么？

<table> 
 <tbody> 
 <tr> 
 <td align="">内置对象</td> 
 <td align="">代表内容</td> 
 <td align="">范围</td> 
 </tr> 
 <tr> 
 <td align="">request </td> 
 <td align="">触发服务调用的请求 </td> 
 <td align="">request </td> 
 </tr> 
 <tr> 
 <td align="">response </td> 
 <td align="">对请求的应答 </td> 
 <td align="">page </td> 
 </tr> 
 <tr> 
 <td align="">session </td> 
 <td align="">为请求的客户创建的session对象 </td> 
 <td align="">session </td> 
 </tr> 
 <tr> 
 <td align="">application </td> 
 <td align="">从 servlet 配置对象获得的 servlet 上下文（如在getServletConfig() ，getContext()的调用中） </td> 
 <td align="">application </td> 
 </tr> 
 <tr> 
 <td align="">out </td> 
 <td align="">向输出流写入内容的对象 </td> 
 <td align="">page </td> 
 </tr> 
 <tr> 
 <td align="">pageContext </td> 
 <td align="">本 JSP 的页面上下文 </td> 
 <td align="">page </td> 
 </tr> 
 <tr> 
 <td align="">page </td> 
 <td align="">实现处理本页当前请求的类的实例 </td> 
 <td align="">page </td> 
 </tr> 
 <tr> 
 <td align="">config </td> 
 <td align="">本 JSP 的 ServletConfig </td> 
 <td align="">page </td> 
 </tr> 
 <tr> 
 <td align="">exception</td> 
 <td align="">表示JSP页面运行时产生的异常</td> 
 <td align="">Page</td> 
 </tr> 
 </tbody> 
</table>

Request对象封装了用户提交的信息，通过调用该对象相应的方法可以获取封装的信息，即使用该对象可以  
获取用户提交的信息。

Session对象是一个JSP内置对象，它在第一个JSP页面被装载时自动创建，完成会话期管理。从一个客户打开浏览器并连接到服务器开始，到客户关闭浏览器离开这个服务器结束，被称为一个会话。当一个客户访问一个服务器时，可能会在这个服务器的几个页面之间切换，服务器应当通过某种办法知道这是一个客户，就需要Session对象。

服务器启动后就产生了这个Application对象，当客户再所访问的网站的各个页面之间浏览时，这个Application对象都时同一个，直到服务器关闭。但是与Session对象不同的时，所有客户的Application对象都时同一个，即所有客户共享这个内置的Application对象。

Out对象是一个输出流，用来向客户端输出数据。Out对象用于各种数据的输出。其常用方法如下。  
    ● out.print()：输出各种类型数据。  
    ● out.newLine()：输出一个换行符。  
    ● out.close()：关闭流。

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#

在一个数组中，求第k大的数，并且输出在数组中的位置：

略。

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#