高级Java面试题集合

高级Java面试题集合（推荐5篇）

高级Java面试题集合 篇1

用编程的方式，我们可以要求(记住这只是一个请求――不是一个命令)JVM通过调用System.gc()方法来运行垃圾回收。

当内存已满，且堆上没有对象可用于垃圾回收时，JVM可能会抛出OutOfMemoryException。

对象在被垃圾回收从堆上删除之前，会运行finalize()方法。我们建议不要用finalize()方法写任何代码。

什么是初始化数据块?

初始化数据块――当创建对象或加载类时运行的代码。

有两种类型的初始化数据块：

静态初始化器：加载类时运行的的代码

实例初始化器：创建新对象时运行的代码

什么是静态初始化器?

请看下面的例子：static{和}之间的代码被称为静态初始化器。它只有在第一次加载类时运行。只有静态变量才可以在静态初始化器中进行访问。虽然创建了三个实例，但静态初始化器只运行一次。

public class InitializerExamples {

static int count;

int i;

static{

//This is a static initializers. Run only when Class is first loaded.

//Only static variables can be accessed

System.out.println(“Static Initializer”);

//i = 6;//COMPILER ERROR

System.out.println(“Count when Static Initializer is run is ” + count);

}

public static void main(String[] args) {

InitializerExamples example = new InitializerExamples();

InitializerExamples example2 = new InitializerExamples();

InitializerExamples example3 = new InitializerExamples();

}

}

示例输出

Static Initializer

Count whenStaticInitializer is run is0.

什么是实例初始化块?

让我们来看一个例子：每次创建类的实例时，实例初始化器中的代码都会运行。

public class InitializerExamples {

static int count;

int i;

{

//This is an instance initializers. Run every time an object is created.

//static and instance variables can be accessed

System.out.println(“Instance Initializer”);

i = 6;

count = count + 1;

System.out.println(“Count when Instance Initializer is run is ” + count);

}

public static void main(String[] args) {

InitializerExamples example = new InitializerExamples();

InitializerExamples example1 = new InitializerExamples();

InitializerExamples example2 = new InitializerExamples();

}

}

示例输出

Instance Initializer

Count when Instance Initializer is run is 1

Instance Initializer

Count when Instance Initializer is run is 2

Instance Initializer

Count when Instance Initializer is run is 3

什么是正则表达式?

正则表达式能让解析、扫描和分割字符串变得非常容易。Java中常用的正则表达式――Patter，Matcher和Scanner类。

什么是令牌化?

令牌化是指在分隔符的基础上将一个字符串分割为若干个子字符串。例如，分隔符;分割字符串ac;bd;def;e为四个子字符串ac，bd，def和e。

分隔符自身也可以是一个常见正则表达式。

String.split(regex)函数将regex作为参数。

给出令牌化的例子?

private static void tokenize(String string,String regex) {

String[] tokens = string.split(regex);

System.out.println(Arrays.toString(tokens));

}

tokenize(“ac;bd;def;e”,“;”);//[ac, bd, def, e]

如何使用扫描器类(Scanner Class)令牌化?

private static void tokenizeUsingScanner(String string,String regex) {

Scanner scanner = new Scanner(string);

scanner.useDelimiter(regex);

List matches = new ArrayList();

while(scanner.hasNext()){

matches.add(scanner.next());

}

System.out.println(matches);

}

tokenizeUsingScanner(“ac;bd;def;e”,“;”);//[ac, bd, def, e]

如何添加小时(hour)到一个日期对象(Date Objects)?

现在，让我们如何看看添加小时到一个date对象。所有在date上的日期操作都需要通过添加毫秒到date才能完成。例如，如果我们想增加6个小时，那么我们需要将6小时换算成毫秒。6小时= 6 * 60 * 60 * 1000毫秒。请看以下的例子。

Date date = new Date();

//Increase time by 6 hrs

date.setTime(date.getTime() + 6 * 60 * 60 * 1000);

System.out.println(date);

//Decrease time by 6 hrs

date = new Date();

date.setTime(date.getTime() - 6 * 60 * 60 * 1000);

System.out.println(date);

如何格式化日期对象?

格式化日期需要使用DateFormat类完成。让我们看几个例子。

//Formatting Dates

System.out.println(DateFormat.getInstance().format(

date));//10/16/12 5:18 AM

java面试题 篇2

1. 新状态：线程已被创建但尚未执行(start 尚未被调用)。

2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。

3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。

四、线程的优先级

线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。

5)你用过哪种设计模式?(瞬联，IBM，aspenTech)

设计:design

模式:pattern

框架:framework

创建模式，结构模式和行为模式

GoF设计模式

A.创建模式

设计模式之Factory(工厂模式)

使用工厂模式就象使用new一样频繁./10/9更新

设计模式之Prototype(原型模式)

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

设计模式之Builder

汽车由车轮 方向盘 发动机很多部件组成，同时，将这些部件组装成汽车也是一件复杂的工作，Builder模式就是将这两种情况分开进行。

设计模式之Singleton(单态模式)

保证一个类只有一个实例,并提供一个访问它的全局访问点 2002/10/9更新

B.结构模式

设计模式之Facade

可扩展的使用JDBC针对不同的数据库编程,Facade提供了一种灵活的实现.

设计模式之Proxy

以Jive为例,剖析代理模式在用户级别授权机制上的应用

设计模式之Adapter

使用类再生的两个方式:组合(new)和继承(extends),这个已经在”thinking in java“中提到过.

设计模式之Composite

就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于和单位做买卖。文章中还对Jive再进行了剖析。

设计模式之Decorator

Decorator是个油漆工,给你的东东的外表刷上美丽的颜色.

设计模式之Bridge

将”牛郎织女“分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合)

设计模式之Flyweight

提供Java运行性能,降低小而大量重复的类的开销.

C.行为模式

设计模式之Template

实际上向你介绍了为什么要使用Java 抽象类,该模式原理简单,使用很普遍.

设计模式之Memento

很简单一个模式,就是在内存中保留原来数据的拷贝.

设计模式之Observer

介绍如何使用Java API提供的现成Observer

设计模式之Chain of Responsibility

各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个.

设计模式之Command

什么是将行为封装,Command是最好的说明.

设计模式之State

状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换.

设计模式之Strategy

不同算法各自封装,用户端可随意挑选需要的算法.

设计模式之Mediator

Mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.

设计模式之Interpreter

主要用来对语言的分析,应用机会不多.

设计模式之Visitor

访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.

设计模式之Iterator

这个模式已经被整合入Java的Collection.在大多数场合下无需自己制造一个Iterator,只要将对象装入Collection中，直接使用Iterator进行对象遍历。

6)请说一下MVC架构(瞬联，IBM，aspenTech)

Model:模型层

View:视图层

Controller:控制层

MVC (Modal View Controler)本来是存在于Desktop程序中的，M是指数据模型，V是指用户界面，C则是控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据你可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。

模型-视图-控制器(MVC)是Xerox PARC在八十年代为编程语言Smalltalk-80发明的一种软件设计模式，至今已被广泛使用。最近几年被推荐为Sun公司J2EE平台的设计模式，并且受到越来越多的使用 ColdFusion 和 PHP 的开发者的欢迎。模型-视图-控制器模式是一个有用的工具箱，它有很多好处，但也有一些缺点。

MVC如何工作

MVC是一个设计模式，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。

视图

视图是用户看到并与之交互的界面。对老式的Web应用程序来说，视图就是由HTML元素组成的界面，在新式的Web应用程序中，HTML依旧在视图中扮演着重要的角色，但一些新的技术已层出不穷，它们包括Macromedia Flash和象XHTML，XML/XSL，WML等一些标识语言和Web services.

如何处理应用程序的界面变得越来越有挑战性。MVC一个大的好处是它能为你的应用程序处理很多不同的视图。在视图中其实没有真正的处理发生，不管这些数据是联机存储的还是一个雇员列表，作为视图来讲，它只是作为一种输出数据并允许用户操纵的方式。

模型

模型表示企业数据和业务规则。在MVC的三个部件中，模型拥有最多的处理任务。例如它可能用象EJBs和ColdFusion Components这样的构件对象来处理数据库。被模型返回的数据是中立的，就是说模型与数据格式无关，这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性。

控制器

控制器接受用户的输入并调用模型和视图去完成用户的需求。所以当单击Web页面中的超链接和发送HTML表单时，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后用确定用哪个视图来显示模型处理返回的数据。

现在我们总结MVC的处理过程，首先控制器接收用户的请求，并决定应该调用哪个模型来进行处理，然后模型用业务逻辑来处理用户的请求并返回数据，最后控制器用相应的视图格式化模型返回的数据，并通过表示层呈现给用户。

为什么要使用 MVC

大部分Web应用程序都是用像ASP，PHP，或者CFML这样的过程化语言来创建的。它们将像数据库查询语句这样的数据层代码和像HTML这样的表示层代码混在一起。经验比较丰富的开发者会将数据从表示层分离开来，但这通常不是很容易做到的，它需要精心的计划和不断的尝试。MVC从根本上强制性的将它们分开。尽管构造MVC应用程序需要一些额外的工作，但是它给我们带来的好处是无庸质疑的。

首先，最重要的一点是多个视图能共享一个模型，正如我所提及的，现在需要用越来越多的方式来访问你的应用程序。对此，其中一个解决之道是使用MVC，无论你的用户想要Flash界面或是 WAP 界面;用一个模型就能处理它们。由于你已经将数据和业务规则从表示层分开，所以你可以最大化的重用你的代码了。

由于模型返回的数据没有进行格式化，所以同样的构件能被不同界面使用。例如，很多数据可能用HTML来表示，但是它们也有可能要用Macromedia Flash和WAP来表示。模型也有状态管理和数据持久性处理的功能，例如，基于会话的购物车和电子商务过程也能被Flash网站或者无线联网的应用程序所重用。

因为模型是自包含的，并且与控制器和视图相分离，所以很容易改变你的应用程序的数据层和业务规则。如果你想把你的数据库从MySQL移植到Oracle，或者改变你的基于RDBMS数据源到LDAP，只需改变你的模型即可。一旦你正确的实现了模型，不管你的数据来自数据库或是LDAP服务器，视图将会正确的显示它们。由于运用MVC的应用程序的三个部件是相互对立，改变其中一个不会影响其它两个，所以依据这种设计思想你能构造良好的松偶合的构件。

对我来说，控制器的也提供了一个好处，就是可以使用控制器来联接不同的模型和视图去完成用户的需求，这样控制器可以为构造应用程序提供强有力的手段。给定一些可重用的模型和视图，控制器可以根据用户的需求选择模型进行处理，然后选择视图将处理结果显示给用户。

MVC的缺点

MVC的缺点是由于它没有明确的定义，所以完全理解MVC并不是很容易。使用MVC需要精心的计划，由于它的内部原理比较复杂，所以需要花费一些时间去思考。

你将不得不花费相当可观的时间去考虑如何将MVC运用到你的应用程序，同时由于模型和视图要严格的分离，这样也给调试应用程序到来了一定的困难。每个构件在使用之前都需要经过彻底的测试。一旦你的构件经过了测试，你就可以毫无顾忌的重用它们了。

根据我个人经验，由于我们将一个应用程序分成了三个部件，所以使用MVC同时也意味着你将要管理比以前更多的文件，这一点是显而易见的。这样好像我们的工作量增加了，但是请记住这比起它所能带给我们的好处是不值一提。

MVC并不适合小型甚至中等规模的应用程序，花费大量时间将MVC应用到规模并不是很大的应用程序通常会得不偿失。

MVC是一条创建软件的好途径

MVC设计模式是一个很好创建软件的途径，它所提倡的一些原则，像内容和显示互相分离可能比较好理解。但是如果你要隔离模型、视图和控制器的构件，你可能需要重新思考你的应用程序，尤其是应用程序的构架方面。如果你肯接受MVC，并且有能力应付它所带来的额外的工作和复杂性，MVC将会使你的软件在健壮性，代码重用和结构方面上一个新的台阶。

7)如果类a继承类b，实现接口c，而类b和接口c中定义了同名变量，请问会出现什么问题?(瞬联)

interface A

{

int x = 0;

}

class B

{

int x =1;

}

class C extends B implements A

{

public void pX()

{

System.out.println(x);

}

public static void main(String[] args) {

new C().pX();

}

}

答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配(就象在同时import java.util和java.sql两个包时直接声明Date一样)。对于父类的变量,可以用super.x来明确(输出的是1)，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确(输出的是0)。

下面的代码运行时会不会报错

interface Playable

{

void play();

}

interface Bounceable

{

void play();

}

interface Rollable extends Playable, Bounceable

{

Ball ball = new Ball(”PingPang“);

}

class Ball implements Rollable

{

private String name;

public String getName()

{

return name;

}

public Ball(String name)

{

this.name = name;

}

public void play()

{

ball = new Ball(”Football“);

System.out.println(ball.getName());

}

}

答案: 错。”interface Rollable extends Playable, Bounceable“没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的”Ball ball = new Ball(“PingPang”);“。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说”Ball ball = new Ball(“PingPang”);“实际上是”public static final Ball ball = new Ball(“PingPang”);“。在Ball类的Play()方法中，”ball = new Ball(“Football”);“改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在”ball = new Ball(“Football”);“这里显示有错。

8)请说一下java中为什么要引入内部类?还有匿名内部类?(瞬联，IBM)

9)请说一下final，finally和finalize的区别?(瞬联)

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

10)请说一下HTTP请求的基本过程(IBM)

11)java中存在内存泄漏问题吗?请举例说明?(IBM)

会

int i,i2; return (i-i2); //when i为足够大的正数,i2为足够大的负数。结果会造成溢位，导致错误。

12)请说一下java中的内存回收机制所采用的算法(IBM，瞬联)

java面试编程题 篇3

import java.util.*;

public class bycomma{

public static String[] splitStringByComma(String source){

if(source==null||source.trim.equals(“”))

return null;

StringTokenizer commaToker = new StringTokenizer(source,“,”);

String[] result = new String[commaToker.countTokens()];

int i=0;

while(commaToker.hasMoreTokens()){

result[i] = commaToker.nextToken();

i++;

}

return result;

}

public static void main(String args[]){

String[] s = splitStringByComma(“5,8,7,4,3,9,1”);

int[] ii = new int[s.length];

for(int i = 0; i

ii[i] =Integer.parseInt(s[i]);

}

Arrays.sort(ii);

//asc

for(int i=0;i

System.out.println(ii[i]);

}

//desc

for(int i=(s.length-1);i>=0;i--){

System.out.println(ii[i]);

}

}

}

2.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半 个”。

代码：

public static boolean isLetter(char c){

int k=0X80;

return c/k==0?true:false;

}

public static int lengths(String strSrc){

if (strSrc==null){

return 0;

}

int len=0;

char[] strChar=strSrc.toCharArray();

for (int i=0;i

len++;

if (!isLetter(strChar[i])) len++;

}

return len;

}

public static String subString(String origin,int len){

if (origin==null || origin.equals(“”)|| len<1){

return “”;

}

if (len>lengths(origin)){

return origin;

}

byte[] strByte=new byte[len];

System.arraycopy(origin.getBytes(),0,strByte,0,len);

int count=0;

for (int i=0;i

int value=(int)strByte[i];

if (value<0) count++;

}

if (count % 2 !=0){

//len=(len==1)?++len:--len;

--len;

}

return new String(strByte,0,len);

}

public static void main(String[] args) {

System.out.println(“”+ subString(“我ABC汉DEF”,6));

}

3、排序都有哪几种方法?请列举。用JAVA实现一个快速排序。

排序的方法有：插入排序(直接插入排序、希尔排序)，交换排序(冒泡排序、快速排序)，选择排序(直接选择排序、堆排序)，归并排序，分配排序(箱排序、基数排序)

快速排序的伪代码。

/ /使用快速排序方法对a[ 0 :n- 1 ]排序从a[ 0 :n- 1 ]中选择一个元素作为m I d d l e，该元素为支点把余下的元素分割为两段left 和r I g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点递归地使用快速排序方法对left 进行排序递归地使用快速排序方法对right 进行排序所得结果为l e f t + m I d d l e + r I g h t

//以下为java程序实现的快速排序算法：

public static void sort(int[] data) {

quickSort(data,0,data.length-1);

}

public static void quickSort(int[] data,int low,int high){

int pivotIndex=(low+high)/2;

swap(data,pivotIndex,high);

int k=partition(data,low-1,high,data[high]);

swap(data,k,high);

if ((k-low)>1) partition(data,low,k-1);

if ((high-k)>1) partition(data,k+1,high);

}

public static int partition(int[] data int low,int high, int pivot ){

do {

while (data[++low]

while (high!=0 && data[--high]>pivot);

swap(data,low,high);

}

while (low

swap(data,low,high);

return low;

}

public static void swap(int[] data int low,int high){

int tmp=data[low];

data[low]=data[high];

data[high]=tmp;

}

public static void main(String[] args){

int[] data = new int[]{89,32,425,32,78,1,53,92};

sort(data);

}

4.试用递归的方法写一下计算菲波那契数列的通项f(n),已知f1=1,f2=1,以后每项都是前两项的和。

..............

public static long fibonacci(long m){

if (m==0 || m==1) return m;

else return fibonacci(m-1)+fibonacci(m-2);

}

5. 写一个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;

}

}

其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

6、创建一个静态方法，给它传入一个对象，请循环的打印出该对象所在类的类名和所实现的方法名(华为笔试最后一道编程)

import java.lang.reflect.*;

public class Test{

public static void test(Object obj){

Class clazz=obj.getClass();

//System.out.println(“类名:”+clazz.getName());

Method[] ms=clazz.getDeclaredMethods();

long len=Array.getLength(ms);

for(int i=0;i

System.out.println(“类名:”+clazz.getName()+“方法名:”+ms[i].getName());

}

}

class A{

public void b(){}

public void c(){}

public void d(){}

public void e(){}

}

public static void main(String[] args){

Test t=new Test();

Test.A a=t.new A();

test(a);

}

}

7、假设字符串类似这样的aba和aab就相等，现在随便给你二组字符串，请编程比较他们看是否相等

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String s = null;

try {

s = br.readLine();

} catch (IOException e) {

e.printStackTrace();

}

StringTokenizer st = new StringTokenizer(s);

String s1 = st.nextToken();

String s2 = st.nextToken();

byte[] sa1 = s1.getBytes();

byte[] sb2 = s2.getBytes();

Arrays.sort(sa1);

Arrays.sort(sb2);

String ss1 = new String(sa1);

String ss2 = new String(sb2);

if(ss1.equals(ss2))

System.out.println(“equal”);

else

System.out.println(“not equal”);

8、给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：7842

用正规表达式：“iu7i8hy4jnb2”.replaceAll(“[^d]”,“”);

9、给你一组字符串让你把它倒叙输出

public static String flashBack(String origin) {

String result = “”;

for (int i = origin.length(); i >0; i--) {

String tmp = origin.substring(i - 1, i);

result += tmp;

}

return result;

}

10、给你一组字符如{1，3，4，7，2，1，1，5，2}，让你输出里面出现次数最多且数值最大的一个，出现几次

public void fun4() {

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

Arrays.sort(a);

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

System.out.print(a[i] + “ ”);

}

System.out.println();

int maxNumber = a[a.length - 1], maxCount = 1;

int curNumber = a[a.length - 1], curCount = 1;

for (int i = a.length - 1; i >0; i--) {

curNumber = a[i];

if (a[i] == a[i - 1]) {

curCount++;

} else {

System.out.println(“i=” + i + “,curCount=” + curCount+ “,maxCount=” + maxCount + “,maxNumber=” + maxNumber);

if (curCount >maxCount) {

maxCount = curCount;

maxNumber = curNumber;

}

curCount = 1;

}

}

if (curCount >maxCount) {

maxCount = curCount;

//maxNumber = curNumber;

}

System.out.println(“curCount=” + curCount + “,maxCount=” + maxCount + “,maxNumber=” + maxNumber);

}

11、求两个数的公约数，M，N

int divisor =1;

for (int i = 2; i <= b; i++) {

if(a%i==0 && b%i==0){

divisor = i;

}

}

System.out.println(a+“和”+b+“的最大公约数是:”+divisor);

}

12、实现数组复制

public void fun8(){

int[] a = {1,2,3,4,56,7,8};

int[] b = (int[])a.clone();

Conica.print(a);

Conica.print(b);

b[0]=100;

Conica.print(a);

Conica.print(b);

}

13、冒泡排序的实现

public void fun9(){

int[] a = {1,5,2,6,8,74,1,25,69,8};

Conica.print(a);

for(int i=0; i

for(int j=0; j

if(a[j]>a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

Conica.print(a);

}

14、编程显示某一文件目录下的文件名

public void fun10(){

File file = new File(“G:�3月份”);

if(file.exists()){

if(file.isDirectory()){

String[] files = file.list();

Conica.println(files);

}

}

}

15、从键盘输入4个十进制数字字符，将其转换为4位时间之数并显示出来

16、编程实现统计文本文件中某个单词的出现频率，并输出统计结果

用HashMap来解决

假设单词不存在跨行的,每个单词用,. ;分割

public static void countNum() throws IOException {

BufferedReader br = null;

try {

br = new BufferedReader(new FileReader(“c://file.txt”));

Map map = new HashMap();

for (String s = br.readLine(); s != null; s = br.readLine()) {

StringTokenizer st = new StringTokenizer(s, “,. ;”);

while (st.hasMoreTokens()) {

String temp = st.nextToken();

if (map.containsKey(temp)) {

map.put(temp, new Integer((Integer)map.get(temp) + 1));

} else {

map.put(temp, new Integer(1));

}

}

}

for (Iterator it = map.entrySet().iterator(); it.hasNext();) {

Map.Entry entry = (Map.Entry) it.next();

System.out.println(entry.getKey() + “-->” + entry.getValue()

+ “times”);

}

} finally {

br.close();

}

}

17、编程模仿DOS下的dir命令，列出某个目录下的内容

18、编程说明String和StringBuffer字符串的区别

19、编程计算N!的程序，一个使用递归方法，一个不用递归方法

递归 :

long fuction(int n){

if (n==0) return 1;

else

return n* fuction(n-1);

}

不递 :

long s=1;

for(int i=2;i<=n;i++)

{

s*=i;

}

20、编程实现ASCII码和Unicode码之间的转换

21.用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求： “4 ”不能在第三位， “3 ”与 “5 ”不能相连.

此题具体算法及程序可参考：

topic.csdn.net/u/0114/14/1170e023-e8f0-4331-8bd8-516c6f1e40da.html

22。一个字符串中可能包含a~z中的多个字符，如有重复，如String data=“aavzcadfdsfsdhshgWasdfasdf”，求出现次数最多的那个字母及次数，如有多个重复的则都求出。〔金山公司面试题〕

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.TreeSet;

public class FindRepeatChar {

public static void doString(String strInput) {

char[] chars = strInput.toCharArray();

ArrayList lists = new ArrayList();

TreeSet set = new TreeSet();

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

lists.add(String.valueOf(chars[i]));

set.add(String.valueOf(chars[i]));

}

System.out.println(set);

Collections.sort(lists);

System.out.println(lists);

StringBuffer sb = new StringBuffer();

for (int i = 0; i < lists.size(); i++) {

sb.append(lists.get(i));

}

strInput = sb.toString();

System.out.println(strInput);

int max = 0;

String maxString = “”;

ArrayList maxList = new ArrayList();

for (Iterator its = set.iterator(); its.hasNext();) {

String s = (String) its.next();

int begin = strInput.indexOf(os);

int end = strInput.lastIndexOf(os);

int value = end - begin + 1;

if (value >max && value >1) {

max = value;

maxString = os;

maxList.add(os);

} else if (value == max) {

maxList.add(os);

}

}

int index = 0;

for (int i = 0; i < maxList.size(); i++) {

if (maxList.get(i).equals(maxString)) {

index = i;

break;

}

}

System.out.println(“出现最多的字符为：”);

for (int i = 0; i < maxList.size(); i++) {

System.out.println(maxList.get(i) + “”);

}

System.out.println();

System.out.println(“出现最多的次数为：” + max);

}

public static void main(String[] args) {

String strInput = new String(“aavzcadfdsfsdhshgWasdfasdf”);

doString(strInput);

}

}

23.金额转换，阿拉伯数字的金额转换成中国传统的形式如：(￥1011)->(一千零一拾一元整)输出。

package test.money;

import java.text.NumberFormat;

import java.util.HashMap;

public class SimpleMoneyFormat {

public static final String EMPTY = “”;

public static final String ZERO = “零”;

public static final String NE = “壹”;

public static final String TWO = “贰”;

public static final String THREE = “叁”;

public static final String FOUR = “肆”;

public static final String FIVE = “伍”;

public static final String SIX = “陆”;

public static final String SEVEN = “柒”;

public static final String EIGHT = “捌”;

public static final String NINE = “玖”;

public static final String TEN = “拾”;

public static final String HUNDRED = “佰”;

public static final String THOUSAND = “仟”;

public static final String TEN_THOUSAND = “万”;

public static final String HUNDRED_MILLION = “亿”;

public static final String YUAN = “元”;

public static final String JIAO = “角”;

public static final String FEN = “分”;

public static final String DOT = “.”;

private static SimpleMoneyFormat formatter = null;

private HashMap chineseNumberMap = new HashMap();

private HashMap chineseMoneyPattern = new HashMap();

private NumberFormat numberFormat = NumberFormat.getInstance();

private SimpleMoneyFormat() {

numberFormat.setMaximumFractionDigits(4);

numberFormat.setMinimumFractionDigits(2);

numberFormat.setGroupingUsed(false);

chineseNumberMap.put(“0”, ZERO);

chineseNumberMap.put(“1”, ONE);

chineseNumberMap.put(“2”, TWO);

chineseNumberMap.put(“3”, THREE);

chineseNumberMap.put(“4”, FOUR);

chineseNumberMap.put(“5”, FIVE);

chineseNumberMap.put(“6”, SIX);

chineseNumberMap.put(“7”, SEVEN);

chineseNumberMap.put(“8”, EIGHT);

chineseNumberMap.put(“9”, NINE);

chineseNumberMap.put(DOT, DOT);

chineseMoneyPattern.put(“1”, TEN);

chineseMoneyPattern.put(“2”, HUNDRED);

chineseMoneyPattern.put(“3”, THOUSAND);

chineseMoneyPattern.put(“4”, TEN_THOUSAND);

chineseMoneyPattern.put(“5”, TEN);

chineseMoneyPattern.put(“6”, HUNDRED);

chineseMoneyPattern.put(“7”, THOUSAND);

chineseMoneyPattern.put(“8”, HUNDRED_MILLION);

}

public synchronized static SimpleMoneyFormat getInstance() {

if (formatter == null)

formatter = new SimpleMoneyFormat();

return formatter;

}

public String format(String moneyStr) {

checkPrecision(moneyStr);

String result;

result = convertToChineseNumber(moneyStr);

result = addUnitsToChineseMoneyString(result);

return result;

}

public String format(double moneyDouble) {

return format(numberFormat.format(moneyDouble));

}

public String format(int moneyInt) {

return format(numberFormat.format(moneyInt));

}

public String format(long moneyLong) {

return format(numberFormat.format(moneyLong));

}

public String format(Number moneyNum) {

return format(numberFormat.format(moneyNum));

}

private String convertToChineseNumber(String moneyStr) {

String result;

StringBuffer cMoneyStringBuffer = new StringBuffer();

for (int i = 0; i < moneyStr.length(); i++) {//123363

cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(

i, i + 1)));

}

// 拾佰仟万亿等都是汉字里面才有的单位，加上它们

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);

int moneyPatternCursor = 1;

for (int i = indexOfDot - 1; i >0; i--) {

cMoneyStringBuffer.(i, chineseMoneyPattern.get(EMPTY

+ moneyPatternCursor));

moneyPatternCursor = moneyPatternCursor == 8 ? 1

: moneyPatternCursor + 1;

}

String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer

.indexOf(“.”));

cMoneyStringBuffer.(cMoneyStringBuffer.indexOf(“.”),

cMoneyStringBuffer.length());

while (cMoneyStringBuffer.indexOf(“零拾”) != -1) {//inclusive. exclusive.

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零拾”),

cMoneyStringBuffer.indexOf(“零拾”) + 2, ZERO);

}

while (cMoneyStringBuffer.indexOf(“零佰”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零佰”),

cMoneyStringBuffer.indexOf(“零佰”) + 2, ZERO);

}

while (cMoneyStringBuffer.indexOf(“零仟”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零仟”),

cMoneyStringBuffer.indexOf(“零仟”) + 2, ZERO);

}

while (cMoneyStringBuffer.indexOf(“零万”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零万”),

cMoneyStringBuffer.indexOf(“零万”) + 2, TEN_THOUSAND);

}

while (cMoneyStringBuffer.indexOf(“零亿”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零亿”),

cMoneyStringBuffer.indexOf(“零亿”) + 2, HUNDRED_MILLION);

}

while (cMoneyStringBuffer.indexOf(“零零”) != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零零”),

cMoneyStringBuffer.indexOf(“零零”) + 2, ZERO);

}

if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)

cMoneyStringBuffer.(cMoneyStringBuffer.length() - 1,

cMoneyStringBuffer.length());

cMoneyStringBuffer.append(fractionPart);

result = cMoneyStringBuffer.toString();

return result;

}

private String addUnitsToChineseMoneyString(String moneyStr) {

String result;

StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);

cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);

cMoneyStringBuffer.(cMoneyStringBuffer.length() - 1, JIAO);

cMoneyStringBuffer.(cMoneyStringBuffer.length(), FEN);

if (cMoneyStringBuffer.indexOf(“零角零分”) != -1)// 没有零头，加整

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零角零分”),

cMoneyStringBuffer.length(), “整”);

else if (cMoneyStringBuffer.indexOf(“零分”) != -1)// 没有零分，加整

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf(“零分”),

cMoneyStringBuffer.length(), “整”);

else {

if (cMoneyStringBuffer.indexOf(“零角”) != -1)

cMoneyStringBuffer.(cMoneyStringBuffer.indexOf(“零角”),

cMoneyStringBuffer.indexOf(“零角”) + 2);

// tmpBuffer.append(“整”);

}

result = cMoneyStringBuffer.toString();

return result;

}

private void checkPrecision(String moneyStr) {//5336.53663 10-5-1

int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;

if (fractionDigits >2)

throw new RuntimeException(“金额” + moneyStr + “的小数位多于两位。”); // 精度不能比分低

}

public static void main(String[] args) {

System.out.println(getInstance().format(new Double(8951.11)));

}

}

Java开发岗位面试题 篇4

1. String类为什么是final的。

2. HashMap的源码，实现原理，底层结构。

3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯。。。

4. 描述一下ArrayList和LinkedList各自实现和区别

5. Java中的队列都有哪些，有什么区别。

6. 反射中，Class.forName和classloader的区别

7. Java7、Java8的新特性(baidu问的,好BT)

8. Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高

9. Java内存泄露的问题调查定位：jmap，jstack的使用等等

10. string、stringbuilder、stringbuffer区别

11. hashtable和hashmap的区别

13 .异常的结构，运行时异常和非运行时异常，各举个例子

14. String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c” .他们之间用 == 比较的结果

15. String 类的常用方法

16. Java 的引用类型有哪几种

17. 抽象类和接口的区别

18. java的基础类型和字节大小。

19. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题(建议熟悉 jdk 源码，才能从容应答)

20. 如果不让你用Java Jdk提供的工具，你自己实现一个Map，你怎么做。说了好久，说了HashMap源代码，如果我做，就会借鉴HashMap的原理，说了一通HashMap实现

21. Hash冲突怎么办?哪些解决散列冲突的方法?

22. HashMap冲突很厉害，最差性能，你会怎么解决?从O(n)提升到log(n)咯，用二叉排序树的思路说了一通

23. rehash

24. hashCode() 与 equals() 生成算法、方法怎么重写

二、Java IO

1. 讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。

2. 讲讲NIO。

3. String 编码UTF-8 和GBK的区别?

4. 什么时候使用字节流、什么时候使用字符流?

5. 递归读取文件夹下的文件，代码怎么实现

三、Java Web

1. session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。

2. servlet的一些相关问题

3. webservice相关问题

4. jdbc连接，forname方式的步骤，怎么声明使用一个事务。举例并具体代码

5. 无框架下配置web.xml的主要配置内容

6. jsp和servlet的区别

四、JVM

1. Java的内存模型以及GC算法

2. jvm性能调优都做了什么

3. 介绍JVM中7个区域，然后把每个区域可能造成内存的溢出的情况说明

4. 介绍GC 和GC Root不正常引用。

5. 自己从classload 加载方式，加载机制说开去，从程序运行时数据区，讲到内存分配，讲到String常量池，讲到JVM垃圾回收机制，算法，hotspot。反正就是各种扩展

6. jvm 如何分配直接内存， new 对象如何不分配在堆而是栈上，常量池解析

7. 数组多大放在 JVM 老年代(不只是设置 PretenureSizeThreshold ，问通常多大，没做过一问便知)

8. 老年代中数组的访问方式

Java程序员面试题 篇5

1、面向对象的特征有哪些方面? 答：面向对象的特征主要有以下几个方面：1)抽象2)继承3)封装4)多态性

2、作用域public,private,protected,以及不写时的区别 答：区别如下：

作用域 当前类 同包 子类 其他 public √ √√ √ protected√√√ × default √√× × private √×××

类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。

3、String 是最基本的数据类型吗? 答：不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型（reference type）。

4、float f=3.4;是否正确? 答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4;或者写成float f =3.4F。

5、int 和Integer 有什么区别? 答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入不是对象的基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的封装类就是Integer，从JDK 1.5开始引入了自动封箱/解封箱机制，使得二者可以相互转换。

Java 为每个原始类型提供了封装类：

原始类型: boolean，char，byte，short，int，long，float，double 封装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

6、数组有没有length()方法?String 有没有length()方法？

答：数组没有length()方法，有length 的属性。String 有length()方法。

7、在Java 中，如何跳出当前的多重嵌套循环？

答：在最外层循环前加一个标记如A，然后用break A;可以跳出多重循环。

8、是否可以继承String 类? 答：String 类是final类，不可以被继承。

9、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对象的引用是永远不会改变的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值

10、抽象类（abstract class）和接口（interface）有什么异同? 答：

抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。

一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。

抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

11、静态变量和实例变量的区别？

答：静态变量也称为类变量，属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。

12、String s=new String(“xyz”);创建了几个字符串对象？

答：两个对象，一个是静态存储区的“xyx”,一个是用new创建在堆上的对象

13、接口是否可继承（extends）接口? 抽象类是否可实现（implements）接口? 抽象类是否可继承具体类（concrete class）? 答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承具体类，但前提是具体类必须有明确的构造函数

14、Java 中的final关键字有哪些用法？

答：(1)修饰类：表示该类不能被继承；(2)修饰方法：表示方法不能被重写；(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）

15、Error 和Exception 有什么区别? 答：Error 表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；Exception 表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

选择题

1、在Java

Applet程序用户自定义的Applet子类中，一般需要重载父类的(D)方法来完成一些画图操作。

A.start()

B.stop()

C.init()D.paint()

2、Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？（B）

A)安全性

B)多线程

C)跨平台

D)可移植

3、下列哪个类声明是正确的？（D）

A)abstract final class HI{···｝ B)abstract private move(){···}C)protected private number;

D)public abstract class Car{···

4、在Java语言中，下列哪些语句关于内存回收的说明是正确的?（B）

A．程序员必须创建一个线程来释放内存；

B．内存回收程序负责释放无用内存

C．内存回收程序允许程序员直接释放内存

D．内存回收程序可以在指定的时间释放内存对象

5、字符串是Java已定义的类型，关于它的构造函数，下面说法不正确的是： B

A．String(char[] value, int offset, int count)

B．String(int[] codePoints,int offset,int count)

C．String(String original)

D．String(StringBuffer buffer)

6、下列说法中正确的是： C

A．导入包会影响程序的性能 B.包存储在类库中

C．包是类的容器D．上述说法都不对

7、哪个关键字可以对对象加互斥锁？ B

A．transient

B．synchronized

C．serialize

D．static8、下列叙述中，错误的是： D

A、父类不能替代子类

B、子类能够替代父类

C、子类继承父类

D、父类包含子类

9、下列关于Java多线程并发控制机制的叙述中，错误的是：BC

A、Java中对共享数据操作的并发控制是采用加锁技术

B、线程之间的交互，提倡采用suspend()/resume()方法

C、共享数据的访问权限都必须定义为private

D、Java中没有提供检测与避免死锁的专门机制，但应用程序员可以采用某些策略防止死锁的发生

10、下列哪一个方法不是applet程序的组成部分：D

A、init()

B、start()

C、stop()

D、new()

11、下列Applet类的方法中，在Applet的整个生命周期里至多只执行一次的是：A

A、init()

B、start()C、stop()

D、paint()

12、启动一个线程所调用的方法是：C

A、run()

B、init()

C、start()

D、new()

13、编译Java

Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为（B)。

A..java

B..class

C..html

D..exe

二、填空题（每空格1分，共20分）

1、开发与运行Java程序需要经过的三个主要步骤为编辑源程序、编译生成字节码和解释运行字节码。

2、如果一个Java

Applet源程序文件只定义有一个类，该类的类名MyApplet，则类MyApplet必须是Applet类的子类并且存储该源程序文件的文件名为MyApplet。

3、若x=5，y=10，则x=y的逻辑值分别为true和false。

4、抽象(abstract)方法方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。最终(final)方法方法是不能被当前类的子类重新定义的方法。