java项目经验面试

java项目经验面试（7篇）

1.java项目经验面试 篇一

JAVA程序员面试经验

以下要介绍的是一份JAVA程序员面试经验

1.数据结构，主要涉及java.util包中的一些集合类。

2.OO。按照他的一段描述建模。主要是类的.继承关系以及接口实现。还有构造函数和析构函数在继承体系中的作用等等。

3.Java和C++在内存管理的不同之处。

4.JAVA的多线程机制。

5.反射机制的作用，以及在哪些方面使用了反射机制。

6.网络：TCP/IP协议，

HTTP访问机制。还问到了SSL之类。

7.DesignPatten:用过几种DesignPattern,J2EE中有哪些Pattern已经自动实现等等

8.数据库:比较EJB中的QL语言和SQL。还写了一段QL查询语句。

9.CMP中Home接口,Remote接口是如何实现的。

10.软件工程：常见的开发模型。平常项目管理中软件工程的运用。

技术面试大概从3：40开始，面完已经4：50了。最后面试官说看你的项目经历，再安排一个.Net技术面试。反正到此地 步，只能随意。不一会他回来说，有点晚了，.Net面试就取消吧，不过还有一个英语面试。小吃了一惊，因为根据sirily的 面经，不应该有英语面试的。还好，问了一些很简单的问题，马马虎虎混了过去。

2.java项目经验面试 篇二

国产中间件参考实现及平台

软件环境： j2ee

硬件环境： x86

开发工具： Java

项目描述： 核高基重大专项课题 该课题旨在建立国产中间件标准体系，进而在该标准体系指导下构建国产中间件参考实现与平台，从技术、产品与产业运作机制等方面探索适合国产中间件发展的一体化方案。责任描述： 编写相关文档和设计报告。将Onceportal 4.0中符合JSR 286规范的portlet容器OSGi化。

轻量级数据持久框架

软件环境： j2ee

硬件环境： x86

开发工具： Java

项目描述： 国家863项目子课题 该课题旨在提供一种能够提高小型信息系统持久层的开发效率，降低其在异构数据库之间的迁移成本的数据持久化框架。责任描述： 调研现有持久化技术，编写可行性报告。借鉴已有产品和标准的经验，提取数据持久化通用接口，完成持久化框架总体设计。在Java环境下对框架进行开发，并提供了框架接口在关系数据库、XML数据库和目录数据库下的实现。

基于门户系统的单点登录工具

软件环境： j2ee

硬件环境： x86

开发工具： Java JSp

项目描述： 国家863项目子课题 该课题旨在研究门户环境下如何安全有效的对常见的B/S和C/S应用进行单点登录集成。责任描述： 调研企业B/S和C/S应用的常见认证方式，设计门户环境下B/S和C/S应用单点登录集成工具 OnceportalBSSSO1.0，OnceportalCSSSSO1.0/2.0并使用Java和JSp等相关技术将其实现。

可视化快递追踪分析平台-VisualExpress

软件环境： j2ee

硬件环境： x86

开发工具： Java

3.java面试官面试技巧 篇三

2、介绍自己和公司，把公司的优势做个简单的描述。

3、表明资料来源和招聘的职位，现在很多应聘者是在找工作时，海投简历,如果有必要的话简单介绍职位内容。这样做，就唤起了应聘者的记忆，获得了他的信任，而且还提高了他听电话的注意力。

4、在学历、工作经历等方面适当称赞应聘者，增加应聘者对公司的认同度。

5、告知对方已经通过了简历筛选，让应聘者觉得企业招聘有一定的门槛、流程正规，进一步增加应聘者对企业的认同度。

6、沟通中注意倾听，并恰当的做到将自己的看法拿出和对方分享或讨论。

7、邀约，提供1-2个时间供选择告知至少两个面试时间让对方选择，让对方感受到企业的重视。。

4.java项目经验面试 篇四

那么java程序员到底是一个什么类型的工作，他们需要掌握什么技能呢，而他们在企业面试中又会遇到什么考题呢?经欧泊泰克就业小编总结，在java程序员面试时经常会遇到String类问题，下面就让我们一起分析解决这些问题，让我们程序员们轻松应对。问题1:

String s1 = “abc”;

String s2 = “abc”;

System.out.println(s1 == s2);

这里的结果是true.由于字符串是常量(内存中创建对象后不能修改), 而且字符串在程序中经常使用.所以Java对其提供了缓冲区.缓冲区内的字符串会被共享.使用双引号的形式定义字符串常量就是存储在缓冲区中的.使用“abc”时会先在缓冲区中查找是否存在此字符串, 没有就创建一个, 有则直接使用.第一次使用“abc”时会在缓冲区中创建, 第二次则是直接引用之前创建好的了.问题2:

String s1 = new String(“abc”);

String s2 = new String(“abc”);

System.out.println(s1 == s2);

这里的结果是false.使用构造函数创建的字符串都是在缓冲区外面创建一个新的.所以只要是使用构造函数创建的字符串, 和任何字符串都不会相等.问题3:

String s1 = “abc”;

String s2 = “a”;

String s3 = “bc”;

String s4 = s2 + s3;

System.out.println(s1 == s4);

这里的结果是false.Java中字符串的相加其内部是使用StringBuilder类的append()方法和toString()方法来实现的.而StringBuilder类toString()方法返回的字符串是通过构造函数创建的.问题4:

String s1 = “abc”;

String s2 = “a” + “bc”;

System.out.println(s1 == s2);

这里的结果是true.其实这里的s2并没有进行字符串相加, 两个双引号形式的字符串常量相加, 在编译的时候直接会被转为一个字符串“abc”.问题5:

String str = “abc”;

str.substring(3);

str.concat(“123”);

System.out.println(str);

这里结果是“abc”.由于字符串是常量(内存中创建对象后不能修改), 该类中所有方法都不会改变字符串的值.如果希望使用一个可变的字符串, 可以使用StringBuilder或StringBuffer类。

5.对日Java面试总结 篇五

2：struts和struts2的工作流程；

答：struts工作流程：在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;Struts2工作流程：用户发送请求，在struts.xml文件中找到相应的action请求，根据相应的class类，处理相应的请求，然后返回string字符串，在struts.xml文件中配置的result找到该字符串，到相应的页面。

3：Ajax异步请求；

答：核心是xmlHttpRequest，页面不刷新，直接请求服务器，并返回数据。

4：jquery验证：

答：用js验证，首先编写好要验证的js代码，在jsp页面引入js验证代码，在需要验证的输入框或选择框中用class=“validate[….]”写入验证的需求。

5：struts2 返回什么类型

答：返回string类型，例如”success”,”fail”。

6你会什么技术？ 7介绍自己情况？中文自我介绍。8项目介绍，自己担当模块。9自己担当模块如何实现 10项目用到的框架，原理ssi 11Hibernate与Ibatis区别 12事务如何理解 13对框架的认识

14针对自己模块操作，在检索按钮摁下时，页面如何进行。（表单验证提交，验证的几种方式，ssi如何整合到一块的）

15项目中properties文件如何处理的 16项目框架怎样处理的，（系统已搭建好的，自己模块sourse的dao实现自己配置）

17Db是否熟悉

18日语式样书翻译一句话。19验证都验证些什么？

20证书问题，考证？三级如何评定。21用日语进行自我介绍 22汉译日

23你写过单体测试书吗

24根据什么进行单体测试的

25有一个收费金额的入力框，进行check时，你如何写这个测试case 26在这个项目中，你只写单体测试吗

27首先自我介绍

28谈谈对对日项目开发的理解 29谈谈SSH框架 30谈谈hibernate的理解 31谈谈你对ibatis的理解

Hibernate和Spring是怎么集成的 33 Spring和struts是怎么集成的 34 分页关键字

rownum的作用 35 怎么实现分页的 36 日语怎么样

单测根据什么做成的

Struts2的tag标签

Hibernate中纯sql和语句和hql语句的区别

40介绍最近的项目;41自己担当的模块流程,说说在该项目中用到的技术;42是否用过AJAX与DWR,用的是什么方式发送请求 43 struts2的拦截器

SSH框架搭建是否由自己完成;45 Spring的事物管理;46 用过什么Hibernate的对应关系, 47在项目中参与了设计吗?

48中文自我介绍 49项目介绍 S2标签 51 事务

52你们用的是什么异常处理 53你做的项目名字用日语说一下

54自我介绍

用汉语介绍自己。有的要求日语。55项目经验

56用日语读出某个项目概述 57怎么编写单体测试式样书

根据详细设计书和Source编写,分为大，中，小项目，写测试用例，编写Case点。

58有一个入力框，你会怎么写Case点？

非法字符，入力框的长度，边界值，是否为空，纯数字校验，入力值为最大值，及入力值大于最大值，及大于最大值加1； 59你写过多少单体测试Step？

100行

60在jsp页面的javascript中如果有错误，怎么调试？ 61java中的集合类有哪些？它们的区别有哪些？

62给你一个数组，里面有重复的数据，1、实现数组排序；

2、去掉重复数据

在IE7或8没出现之前，使用IE6时，jsp页面有问题的话，你是怎么解决的？

使用火狐浏览器查看 64 jsp 页面中Div层出错后，修改验证没问题了，但是，发给日方的时候，页面出错了，你怎么办？你有遇到过这个问题？ 65 65写过50多条测试项，后台代码写了多少呢？

300多行

66用日语写过什么作品？在遇到简单的词汇，你会使用Copy键还是自己手敲呢？

简单的会拷贝一些，个人认为，手写的比较有利于日语知识的提升。

介绍一下泛型

DJunit中测试调用什么方法 69 struts1和struts2的区别

hibernate 和 ibatis 的区别以及优缺点。71 BUG票写过吗？ 72 对spring的理解

每千行的测试case大概有多少个。74 list如何去除重复元素。75 SSH的工作流程 76 SSI的工作流程。

开始菜单，事项书，工具，删除，追加，修改，进度表，检索等常用、敏感词的日语单词。78 orcal获取系统当前时间 79 orcal 分页 80 增删改查语句

jsp内置对象

hibernate 一对一，一对多，多对多联系 83 java面向对象的四大特征 84 jsp验证时怎样取数据 85 struts2如何存取数据 86 orcal 左右连接 87 数据库用的什么

操作系统用的是什么 89 Junit和DJunit有什么区别

struts的数据提交怎样实现

一张表中有多条数据，怎样查询第一条 92 jsp基本动作 93 struts 的配置 94 web的servlet 传送 95 存储过程

一个项目的流程

一个输入框，模拟测试点

A=B，能写出几个测试用例

用哪个方法判断两个值相等？说明equals和==的区别。100 说几个常见的runtime exception。

介绍一下你的公司

对详细式样书的感觉怎么样，理解方面有没有问题？ 103 详细式样书遇到问题怎么解决？

QA票写过没有，发给谁？主要写一些什么东西？（发给组长，由组长发给日方客户）

6.Java预备面试题 篇六

答：区别如下：

作用域当前类同一package子孙类其他package

public√√√√

protected√√√×

friendly√√××

private√×××

不写时默认为friendly

 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体

类(concrete class)

答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数

 面向对象的特征有哪些方面

答：主要有以下四方面：

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继 承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继 承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增 加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4.多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

 Java的接口和C++的虚类的相同和不同处

答：由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有 的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属 性，并且接口里面的属性在默认状态下面都是

public static,所有方法默认情况下是public.一个类可以实现多个接口。

 是否可以继承String类

答：String类是final类故不可以继承

 char型变量中能不能存贮一个中文汉字?为什么?

答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的 抽象类与接口？

答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

 STRING与STRINGBUFFER的区别。

答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

 谈谈final, finally, finalize的区别

答：final?修饰符（关键字）如果一个类被声明为final，意味着它不能再派 生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它 们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不 能重载

finally?再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）

finalize? 方法名。Java 技术允许使用 finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这 个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize()方法以整理系统资源 或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的 你所知道的集合类都有哪些？主要方法？

答：最常用的集合类是 List 和 Map。List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。

Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。

 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语句。排序都有哪几种方法？请列举 答：排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）快速排序的伪代码。/ /使用快速排序方法对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中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？ 答：字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。List、Map、Set三个接口，存取元素时，各有什么特点？ 答：List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。是否可以从一个static方法内部发出对非static方法的调用？ 答：不可以,如果其中包含对象的method()；不能保证对象初始化.error和exception有什么区别 答：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况 Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是

equals()? 它们有何区别

答：Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等

7.java面试编程题 篇七

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)));

}

}