标签：
从网上转的一些java基础知识面试题：
1、String是最基本的数据类型吗?
基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
2、int 和 Integer 有什么区别
Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
3、String 和StringBuffer的区别
JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用 StringBuffers来动态构造字符数据。
4、运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
5、说出Servlet的生命周期，并说出Servlet和CGI的区别。
Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。
与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
6、说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
7、Collection 和 Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
8、&和&&的区别。
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。
9、HashMap和Hashtable的区别。
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。
10、final, finally, finalize的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
11、sleep() 和 wait() 有什么区别?
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
13、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
14、abstract class和interface有什么区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
15、forward 和redirect的区别
forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。
16、Static Nested Class 和 Inner Class的不同。
Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。
17、JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现<jsp:include page="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>
18、什么时候用assertion。
assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。
19、说出数据连接池的工作机制是什么?
连接客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。
20、数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。String有length()这个方法。
21、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。
22、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。
23、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。
24、垃圾回收的优点和原理。并考虑2种回收机制。
Java语言中一个显着的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制， Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
25、请说出你所知道的线程同步的方法。
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
26、你所知道的集合类都有哪些？主要方法？
最常用的集合类是 List 和 Map。 List 的具体实现包括
ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。
List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。
27、如何现实servlet的单线程模式
<%@ page isThreadSafe="false"%>
28、JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？
JSP 是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。
29、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？
a: 两种形式 dtd,schema，b: 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)，c:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问
SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问STAX:Streaming API for XML (StAX)
30、j2ee常用的设计模式？说明工厂模式。
Java中的23种设计模式：
Factory（工厂模式），Builder（建造模式），Factory Method（工厂方法模式），
Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式），
Adapter（适配器模式），Bridge（桥梁模式），Composite（合成模式），
Decorator（装饰模式），Flyweight（享元模式），Proxy（代理模式），
Command（命令模式），Interpreter（解释器模式），Visitor（访问者模式），
Iterator（迭代子模式），Mediator（调停者模式），Memento（备忘录模式），
Observer（观察者模式），State（状态模式），Strategy（策略模式），
Template Method（模板方法模式），Chain Of Responsibleity（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
31、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。
用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。
throw语句用来明确地抛出一个"异常"。
throws用来标明一个成员函数可能抛出的各种"异常"。
Finally为确保一段代码不管发生什么"异常"都被执行一段代码。
可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。
32、MVC的各个部分都有那些技术来实现?如何实现?
MVC 是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
33、java中实现多态的机制是什么？
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
34、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。
35、是否可以从一个static方法内部发出对非static方法的调用？
不可以,如果其中包含对象的method()；不能保证对象初始化.
36、List、Map、Set三个接口，存取元素时，各有什么特点？
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
37、开发中都用到了那些设计模式?用在什么场合?
每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。主要用到了MVC的设计模式。用来开发JSP/Servlet或者J2EE的相关应用。简单工厂模式等。
38、BS与CS的联系与区别。
C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。
B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。
C/S 与 B/S 区别：
１．硬件环境不同:
C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.
B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行
２．对安全要求不同
C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.
B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。
３．对程序架构不同
C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.
B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.
４．软件重用不同
C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.
B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子
５．系统维护不同
C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统
B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.
６．处理问题不同
C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统
B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.
７．用户接口不同
C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高
B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.
８．信息流不同
C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低
B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。
39、STRUTS的应用(如STRUTS架构)
Struts 是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。
Struts有如下的主要功能：
一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。
二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。
三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。
40、编程题: 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}
选择排序
public static void main(String[] args){
int[]ary={8,6,3,5,2,1};
ary=selectionSort(ary);
String s=Arrays.toString(ary);
System.out.print(s);
}
public static int[] selectionSort(int[] ary){
for(int i=0;i<ary.length-1;i++){
for(int j=i+1;j<ary.length;j++){
if(ary[i]>ary[j]){
int temp=ary[i];
ary[i]=ary[j];
ary[j]=temp;
}
}
}
return ary;
}
冒泡排序
for(int i=0;i<ary.length-1;i++){
for(int j=0;j<ary.length-i-1;j++){
if(ary[j]>ary[j+1]){
int temp=ary[j];
ary[j]=ary[j+1];
ary[j+1]=temp;
}
}
}
return ary;
用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。
插入排序
for(int i=1;i<ary.length;i++){
int temp=ary[i];
int j;
for(j=i-1;j>=0;j--){
if(temp<ary[j]){
ary[j+1]=ary[j];
}else{
break;
}
}
ary[j+1]=temp;
}
return ary;
打乱排序
import java.util.HashSet;
import java.util.Iterator;
import java,util.Set;
public class Iterator overSetDemo{
public static void main(String[] args){
Set<String> set=new HashSet<String>();
set.add("D");
set.add("A");
set.add("C");
set.add("B");
for(Iteractor i=set.iterator() : i.hasNext();){
String s=(String)i.next();
System.out.print(s+" ");
}
}
}
//MySQL 中的分页查询实现
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import week07.domain.Flight;
import week07.domain.News;
import week07.util.ConnectionUtils;
public class FlightDaoImplForMySQL {
/**
* 分页查询flight表的所有列的数据
*
* @param page
* 第几页
* @param rowsPerPages
* 每页显示行数
* @param con
* 数据库连接
* @return 查询到的数据以News对象的形式存储到List中返回
* @throws Exception
*/
public List<Flight> listPagesNewsDB(int page, int rowsPerPage,
Connection con) throws Exception {
int from = (page - 1) * rowsPerPage;
String sql = "select * from flight limit ?, ?;";
Connection conn = null;
PreparedStatement pStmt = null;
ResultSet rs = null;
Flight flight = null;
List<Flight> flights = new ArrayList<Flight>();
try {
conn = ConnectionUtils.openConnection();
pStmt = conn.prepareStatement(sql);
pStmt.setInt(1, from);
pStmt.setInt(2, rowsPerPage);
rs = pStmt.executeQuery();
while (rs.next()) {
String id = rs.getString(1);
String num = rs.getString(2);
flight = new Flight(id, num);
flights.add(flight);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
ConnectionUtils.closeResultSet(rs);
ConnectionUtils.closeStatement(pStmt);
ConnectionUtils.closeConnection(conn);
}
return flights;
}
public static void main(String[] args) throws Exception {
List<Flight> ff = new FlightDaoImplForMySQL().
listPagesNewsDB(2, 3,
ConnectionUtils.openConnection());
for(Flight f:ff){
System.out.println("=="+f.getId()+"="+f.getNum()+"==");
}
}
}
-------------------------------------------------------------------------------
//Oracle 中的分页查询实现
import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import week07.domain.News;
import week07.util.ConnectionUtils;
public class NewsDaoImpl implements INewsDao {
/**
* 分页查询news表的所有列的数据
*
* @param page
* 第几页
* @param rowsPerPages
* 每页显示行数
* @param con
* 数据库连接
* @return 查询到的数据以News对象的形式存储到List中返回
* @throws Exception
* select news_id, title, content, author, pubDate, rn from(
* select news_id, title, content, author, pubDate, rownum rn
* from news
* where rownum < ? )
* where rn >= ?;
*/
public List<News> listPagesNewsDB(int page, int rowsPerPage,
Connection con) throws Exception {
int from = (page - 1) * rowsPerPage + 1;
int to = from + rowsPerPage;
String sql = "select news_id, title, "
+ "content, author, pubDate, rn " + "from "
+ "(select news_id, title, content, "
+ "author, pubDate, rownum rn "
+ "from news where rownum < ? ) " + "where rn >= ?";
Connection conn = null;
PreparedStatement pStmt = null;
ResultSet rs = null;
News news = null;
List<News> newses = new ArrayList<News>();
try {
conn = ConnectionUtils.openConnection();
pStmt = conn.prepareStatement(sql);
pStmt.setInt(1, to);
pStmt.setInt(2, from);
rs = pStmt.executeQuery();
while (rs.next()) {
news = new News();
news.setNewsId(rs.getLong(1));
news.setTitle(rs.getString(2));
news.setContent(rs.getString(3));
news.setAuthor(rs.getString(4));
news.setPubdate(rs.getDate(5));
newses.add(news);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
ConnectionUtils.closeResultSet(rs);
ConnectionUtils.closeStatement(pStmt);
ConnectionUtils.closeConnection(conn);
}
return newses;
}
}
41、JDBC，Hibernate 分页怎样实现？
答：方法分别为：
1) Hibernate 的分页：
Query query = session.createQuery("from Student");
query.setFirstResult(firstResult);//设置每页开始的记录号
query.setMaxResults(resultNumber);//设置每页显示的记录数
Collection students = query.list();
2) JDBC 的分页：根据不同的数据库采用不同的sql 分页语句
例如: Oracle 中的sql 语句为: "SELECT * FROM (SELECT a.*, rownum r FROM
TB_STUDENT) WHERE r between 2 and 10" 查询从记录号2 到记录号10 之间的所有记录
倒三角
public class daosanjiao {
public static void main(String[] args) {
for(int i=0;i<4;i++)
{
for(int k=0;k<i+1;k++)
{
System.out.print(" ");
}
for(int j=0;j<7-2*i;j++)
{
System.out.print("*");
}
System.out.println();
}
}
}
42、用你熟悉的语言写一个连接ORACLE数据库的程序,能够完成修改和查询工作。答：JDBC示例程序
如下：public void testJdbc(){
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
try{
//step1：注册驱动；
Class.forName("oracle.jdbc.driver.OracleDriver");
//step 2：获取数据库连接；
con=DriverManager.getConnection(
"jdbc:oracle:thin:@192.168.0.23:1521:tarena", "openlab","open123");
/************************查询************************/
//step 3：创建Statement；
String sql = "SELECT id, fname, lname, age, FROM Person_Tbl"; ps = con.prepareStatement(sql);
//step 4 ：执行查询语句，获取结果集；
rs = ps.executeQuery();
//step 5：处理结果集—输出结果集中保存的查询结果；
while (rs.next()){
System.out.print("id = " + rs.getLong("id"));
System.out.print(" , fname = " + rs.getString("fname"));
System.out.print(" , lname = " + rs.getString("lname"));
System.out.print(" , age = " + rs.getInt("age")); }
/************************JDBC 修改*********************/
sql = "UPDATE Person_Tbl SET age=23 WHERE id = ?"; ps = con.prepareStatement(sql);
ps.setLong(1, 88);
int rows = ps.executeUpdate();
System.out.println(rows + " rows affected.");
} catch (Exception e){
e.printStackTrace();
} finally{
try{
//关闭数据库连接，以释放资源。
con.close();
} catch (Exception e1) {
E1.printStackTrace();
} } }
44、Statement,PreparedStatement,CallableStatment的区别
答：区别有以下几点： 1） Statement是PreparedStatement和CallableStatement的父类； 2）Statement是直接发送Sql语句到数据库，事先没有进行预编译。
PreparedStatement会将sql进行预编译，当sql语句要重复执行时，数据库会调用以前预编译好的sql语句，所以PreparedStatement在性能方面会更好；
3）PreparedStatement在执行sql时，对传入的参数可以进行强制的类型转换。以保证数据格式与底层的数据库格式一致。
4）CallableStatement 适用与存储过程的查询表达语句
aop称为是面向切面编程，那么对它最好的解释就是拦截器了，而他的aop原理呢就是：在执行某些代码之前执行另外的代码，是程序变的灵活，扩展性更灵活，可以随意的删除和添加某些功能！你可以参照filter过滤器，其实filter就是一个很好的对aop的解释
AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。
主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。可以更好的将本来不应该粘合在一起的功能分离开。
1.定义切入点：spring根据需要织入通知的类和方法来定义切入点
通知是根据他们的特性织入目标类和方法的，如类名和方法名
2.静态切入点：spring为创建静态切入点提供了方便的父类--StaticMethodMatcherPointcut。
1）要创建自制的静态切入点，只需要继承这个类，实现isMatch()方法
2）当被调用方法的名字与给出的映射名字匹配时，切入点才匹配
3）使用明确的方法名，也可以在名字的起始和结束处使用通配符*。
81、现有1~100共一百个自然数，已随机放入一个有98个元素的数组a[98]。要求写出一个尽量简单的方案，找出没有被放入数组的那2个数，并在屏幕上打印这2个数。注意：程序不用实现自然数随机放入数组的过程。答：
int[] b = new int[]{....存入98个随机的1~100的整数};
int[] a = new int[100];
for(int t : b) a[t-1]=t;
for(int t=0; t < a.length; t++)
if(a[t]==0) System.out.println(t+1);
45、在web应用开发过程中经常遇到输出某种编码的字符，如从GBK到iso8859-1等，如何输出一个某种编码的字符串？
答：public static String translate(String str) {
String tempStr = "";
try {
tempStr = new String(str.getBytes("GBK"), "ISO-8859-1");
tempStr = tempStr.trim();
} catch (Exception e) {
System.err.println(e.getMessage()); }
return tempStr; }
46、JAVA实现一种排序
答：用插入法进行排序代码如下
package com.tarena;
import java.util.*;
class InsertSort {
ArrayList list;
public InsertSort(int num,int mod) {
list = new ArrayList(num);
Random rand = new Random();
System.out.println("The ArrayList Sort Before:");
for (int i=0;i<num ;i++ ) {
list.add(new Integer(Math.abs(rand.nextInt()) % mod + 1)); System.out.println("list["+i+"]="+list.get(i)); } }
public void SortIt() {
Integer tempInt; int MaxSize=1;
for(int i=1;i<list.size();i++) {
tempInt = (Integer)list.remove(i); if(tempInt.intValue()>=((Integer)list.get(MaxSize-1)).intValue()) { list.add(MaxSize,tempInt);
MaxSize++;
System.out.println(list.toString());.
} else { for (int j=0;j<MaxSize ;j++ ) {
if (((Integer)list.get(j)).intValue()>=tempInt.intValue()) {
list.add(j,tempInt); MaxSize++; System.out.println(list.toString()); break; } } } } System.out.println("The ArrayList Sort After:");
for(int i=0;i<list.size();i++) {
System.out.println("list["+i+"]="+list.get(i)); } }
public static void main(String[] args) {
InsertSort sort = new InsertSort(10,100); sort.SortIt(); } }
Copyright Tarena Corporation,2009.All rights reserved } public int getAge() { return age; } public boolean isSex() { return sex; } public int getWeight() { return weight; } }
47.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"，4，应该截为"我AB"，输入"我ABC汉DEF"，6，应该输出为"我ABC"而不是"我ABC+汉的半个"。
答：package com.tarena; class SplitString {
public static String split(String str,int num) {
byte[] strs = str.getBytes();
if(strs[num-1]<0)
{ num=num-1; }
byte[] news = new byte[num];
System.arraycopy(strs,0,news,0,num);
return new String(news); }
public static void main(String[] args) {
String str = split("我ABC", 4);
System.out.println(str);
String str2 = split("我ABC走DEF", 6);
System.out.println(str2); } }
48、请用JAVA实现两个类，分别实现堆栈（Stack)和队列（Queue）操作。
答：public class MyStack {
private List list; public MyStack(){
list = new ArrayList(); }
public boolean isEmpty(){ return list.size() == 0; }
public void push(Object obj){ list.add(obj); }
public Object pop(){
if(list.size()>0){
Object obj = list.get(list.size()-1);
list.remove(list.size()-1); return obj;
}else{ return null; }}
public int getNumber(){ return list.size(); } }
class IntegerQueue { public int[] integerQueue;
// 用来当队列 public int tail;
// 队尾 public int size
;// 队的长度，也可以设置一个默认值，溢出时从新申请
public IntegerQueue(int size) {
integerQueue = new int[size];
this.size = size; tail = 0; }
public void inQueue(int i) {
if (tail < size) {
this.integerQueue[tail] = i; tail++;
} else { System.err.println("溢出啦！"); } }
public int outQueue() { if (tail >= 0) {
int tmp = this.integerQueue[0]; tail--; return tmp;
} else {
System.err.println("队列为空！");
throw new RuntimeException(); } } }
作用域当前类同包子类其它
public √√√√
protected √√√×
private √×××
字符串倒转
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.println("Please input a String:");
String st = in.nextLine();
StringBuilder buffer = new StringBuilder(st);
st = buffer.reverse().toString();
System.out.println("The reverse of the string is: "+st);
}
}
计算日期
DateFormat df = new SimpleDateFormat( "yyyy-MM-dd ");
String d = "2005-11-26 ";
Calendar c = Calendar.getInstance();
c.setTime(df.parse(d));
//System.out.println(c.get (Calendar.WEEK_OF_MONTH));
System.out.println(c.get(Calendar.DAY_OF_WEEK));
1.
以某天(a)为基准，计算n天(b)之后是星期几：
假设该天为星期m，则n天之后是星期q:
q = m + (n % 7)
2.
一年有365天，2001年的今天是星期2, 2002年的今天是:
2 + 365 % 7 = 2 + 1 = 3, 不信你查日历表。
因为 365 = 7 * x + 1, 因此，每过一年的同月同日星期数便加1。
3.
闰年有366天，因此如果月份大于2，则每过一年的同月同日星期数除了要加1，还要再加间隔的闰年数。
4.
每四年有一个闰年，每一百年要减去一个闰年，每四百年要加回一个闰年。
因此，今天是:
(7 - 1) / 4 = 1
(2 + (7 - 1) + 1) % 7 = 9 % 7 = 2, 不信你在窗口右下角的时间上双击鼠标看看是不是星期二。
5.
只要还有一点数学常识，星期的计算公式即可推导出来了。
遍历概念
所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。
遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。
遍历方案
1．遍历方案
从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：
（1）访问结点本身(N)，
（2）遍历该结点的左子树(L)，
（3）遍历该结点的右子树(R)。
以上三种操作有六种执行次序：
NLR、LNR、LRN、NRL、RNL、RLN。
注意：
前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。
2．三种遍历的命名
根据访问结点操作发生位置命名：
① NLR：前序遍历(PreorderTraversal亦称(先序遍历))
——访问结点的操作发生在遍历其左右子树之前。
② LNR：中序遍历(InorderTraversal)
——访问结点的操作发生在遍历其左右子树之中(间)。
③ LRN：后序遍历(PostorderTraversal)
——访问结点的操作发生在遍历其左右子树之后。
注意：
由于被访问的结点必是某子树的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。
遍历算法
1．中序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
(1)遍历左子树；
(2)访问根结点；
(3)遍历右子树。
2．先序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
(1) 访问根结点；
(2) 遍历左子树；
(3) 遍历右子树。
3．后序遍历得递归算法定义：
若二叉树非空，则依次执行如下操作：
(1)遍历左子树；
(2)遍历右子树；
(3)访问根结点。
4．中序遍历的算法实现
用二叉链表做为存储结构，中序遍历算法可描述为：
void InOrder(BinTree T)
{ //算法里①~⑥是为了说明执行过程加入的标号
① if(T) { // 如果二叉树非空
② InOrder(T->lchild)；
③ printf("％c"，T->data)； // 访问结点
④ InOrder(T->rchild);
⑤ }
⑥ } // InOrder
把str1和str2合并成一个新的String [] 并去掉其中重复的部分
String [] str1={"1001","1002","1003"};
String [] str2={"1001","1005","1010","1003"};
Vector v = new Vector();
for (int i = 0; i < str1.length; i ++) {
if (!v.contains(str1[i])) {
v.add(str1[i]);
}
}
for (int i = 0; i < str2.length; i ++) {
if (!v.contains(str2[i])) {
v.add(str2[i]);
}
}
String[] str1= new String[]{"1001","1002","1003"};
String[] str2= new String[]{"1001","1005","1010","1003"};
HashMap hp = new HashMap();
for(int i = 0 ; i < str1.length;i++){
hp.put(str1[i],"");
}
for(int i = 0 ; i < str2.length;i++){
hp.put(str2[i],"");
}
import java.util.*;
public class test1{
public static void main(String [] args){
String [] str1={"1001","1002","1003"};
String [] str2={"1001","1005","1010","1003"};
HashSet sh = new HashSet();
for(int i=0;i<str1.length;i++)
sh.add(str1[i]);
for(int j=0;j<str2.length;j++)
sh.add(str2[j]);
Iterator i =sh.iterator();
while(i.hasNext()){
System.out.println(i.next());
}}}
手机号码
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ClassPathResource {
public static boolean isMobileNO(String mobiles){
Pattern p = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");
Matcher m = p.matcher(mobiles);
System.out.println(m.matches()+"---");
return m.matches();
}
public static void main(String[] args) throws IOException {
System.out.println(ClassPathResource.isMobileNO("12016155153"));
}}
第二种方法：
import java.util.regex.Matcher;
import java.util.regex.Pattern;
String value="手机号";
String regExp = "^[1]([3][0-9]{1}|59|58|88|89)[0-9]{8}$";
Pattern p = Pattern.compile(regExp);
Matcher m = p.matcher(value);
return m.find();//Boolean
sturts与jsp结合
struts2中的Action接收表单传递过来的参数有3种方法：
如，登陆表单login.jsp：
<form action="login" method="post" name="form1">
用户名：<s:textfield name="username"/><br/>
密码：<s:password name="password"/><br/>
<s:submit value="提交"/>
</form>
1.在Action类中定义表单属性，两者属性名称必须一致。提供setter，getter方法。即可接收到表单传过来的参数.
这种接收参数的方法，方便简单，但是结构性不是很好，且当表单传递来的参数很多的时候，整个Action类中充斥着setter，getter方法，程序结构不是很美观。
2.把表单传递过来的参数封装成一个类，然后调用其中的属性.
如，把login.jsp页面要传来的参数进行封装
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
然后再Action方法中，定义该类的对象就可以了，如
public class loginAction extends ActionSupport{
private Users users;
public Users getUsers(){
return users;
}
public void setUsers(Users users){
this.users=users;
}
/*
传递过来的参数都封装在users中了，用getter方法取值就可以了
*/
}
通过这种方法传值，还必须在jsp页面做一下处理，login.jsp中from1的属性名应该改成这样：
登陆表单login.jsp：
<form action="login" method="post" name="form1">
用户名：<s:textfield name="users.username"/><br/>
密码：<s:password name="users.password"/><br/>
<s:submit value="提交"/>
</form>
这种方法，在struts开发中是很常用的一种方法！
3.通过实现ModelDriven接口接收表单数据
首先Action类必须实现ModelDriven接口，同样把表单传来的数据封装起来，Action类中必须实例化该对象，并且要重写getModel()方法
public class loginAction extends ActionSupport implements ModelDriven<Users>{
private Users users =new Users();
public Users getModel(){
return users;
}
/*
表单传来的参数封装在users对象中
表单属性名不需要加上引用users对象，直接传参数名
*/
}
hibernate与jdbc优缺点
1.hibernate和jdbc主要区别就是，hibernate先检索缓存中的映射对象( 即hibernate操作的是对象)，而jdbc则是直接操作数据库.
2.Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate可以用在任何JDBC可以使用的场合
3.Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。
还有一点,正确的使用JDBC技术,它的效率一定比hibernate要好,因为hibernate是基于jdbc的技术.
hibernate是jdbc的轻量级封装，包括jdbc的与数据库的连接（用hibernate.property的配置文件实现当然本质是封装了jdbc的forname），和查询，删除等代码，都用面向对象的思想用代码联系起来，hibernate通过hbm 配置文件把po类的字段和数据库的字段关联起来比如数据库的id,在po类中就是pravite Long id;
public Long getId()
public setId(Long id);然后hql语句也是面向对象的，它的查询语句不是查询数据库而是查询类的,这些实现的魔法就是xml文件，其实hibernate=封装的jdbc+xml文件
数据库优化
设计数据库的优化措施。这要看你对预期的数据量的一个估计，不同的数据量有不同的策略。100万数据的表和1亿的数据表的策略肯定是不一样的。同样的设计，查询语句不一样，效果可能也不一样。
比较常用的数据库设计方面的处理措施是，
1、索引的建立，一张表，如果有一些经常查询的字段上，要建立索引。比如库存表，你会经常按厂家查询，那么在厂家这个字段上就要建立索引。如楼上所说，在某些时刻，要采取违反第3范式的一些数据库设计手段。
2、分库，分表技术。可以按业务层次，或者日期、厂家、地区等字段，对表进行横向或纵向的分割。把事务表和数据仓库表分开等。
3、事实上，对于系统的优化，从数据库本身的优化，数据库表的设计，以及应用程序的设计上，关联是很密切的。比如在数据库，可以把临时表，或者一些日志类的表放在内存盘中。在程序设计上，采用缓存机制，分布式数据库机制等等，都是提高系统响应能力的方法。
数据库的优化和你的业务、流量、硬件是分不开的
业务：主要指查询的方式，读写权重，表大小
流量：主要考虑并发请求数
硬件：主要是内存、磁盘、CPU的环境
从业务角度讲：
简单查询只需要对查询条件的列建立索引
需要排序的查询就应该使用符合索引，使排序从文件系统转移到内存中
读写要考虑效率和锁的问题，如果两方面都比较突出，可以考虑建立主从，主服务器做写操作，从服务器做读，读的压力大，可以建立多个从
表的大小直接影响查询效率，单个表的数据量有几十万效率就很低了，可以考虑hash分表，利用表中的某个比较符合业务的字段做分表
如业务需要处理订单之类，需要完整的处理过程，应该选择带有事务处理的存储引擎，如mysql 的 innodb
从流量角度讲：
最主要的是选择适合的存储引擎，mysql的myisam的表级锁会对引擎适合并发较低的环境，但查询速度较快，随着并发的增加，效率支线下降，innodb的行级锁查询速度没有myisam快，但是极大的减少了锁，是并发的效率大大增加，对高并发的环境是不二选择
从硬件角度讲：
内存要合理分配，尤其是事务型的存储引擎，建议内存从小到大的逐渐调整，过大的使用内存会导致使用swap
磁盘的io通常是数据库的主要瓶颈，在你表设计已经比较合理的情况下，io效率依然低下，可以考虑分磁盘存储数据，最好可以使用raid负载磁盘阵列，用多个磁盘分担io的压力
这个年代没有人用单核的处理器，所以多核处理器是最佳选择
总的来说数据库的优化由sql、内存、磁盘IO、表结构、存储引擎等几个主要方面，优化是个过程，没有标准，具体问题具体分析
标签：
原文地址：http://www.cnblogs.com/yuanting/p/4854014.html
