下面是小编整理的Java数据库编程中的几个常用技巧，本文共7篇，欢迎您阅读分享借鉴，希望对您有所帮助。本文原稿由网友“斗战佛库洛米酱”提供。
篇1：Java数据库编程中的几个常用技巧
1、java数据库操作基本流程
2、几个常用的重要技巧：
可滚动、更新的记录集
批量更新
事务处理
java数据库操作基本流程：取得数据库连接 - 执行sql语句 - 处理执行结果 - 释放数据库连接
1、取得数据库连接
1）用DriverManager取数据库连接
例子：
String className,url,uid,pwd;
className = “oracle.jdbc.driver.OracleDriver”;
url = “jdbc:oracle:thin:@127.0.0.1:1521:orasvr;
uid = ”system“;
pwd = ”manager“;
Class.forName(className);
Connection cn = DriverManager.getConnection(url,uid,pwd);
2）用jndi(java的命名和目录服务)方式
例子
String jndi = ”jdbc/db“;
Context ctx = (Context) new InitialContext.lookup(”java:comp/env“);
DataSource ds = (DataSource) ctx.lookup(jndi);
Connection cn = ds.getConnection();
多用于jsp中
2、执行sql语句
1）用Statement来执行sql语句
String sql;
Statement sm = cn.createStatement();
sm.executeQuery(sql); // 执行数据查询语句（select）
sm.executeUpdate(sql); // 执行数据更新语句（、update、、drop等）statement.close();
2）用PreparedStatement来执行sql语句
String sql;
sql = ” into user (id,name) values (?,?)“;
PreparedStatement ps = cn.prepareStatement(sql);
ps.setInt(1,xxx);
ps.setString(2,xxx);
...
ResultSet rs = ps.executeQuery(); // 查询
int c = ps.executeUpdate(); // 更新
3、处理执行结果
查询语句，返回记录集ResultSet。
更新语句，返回数字，表示该更新影响的记录数。
ResultSet的方法：
1、next()，将游标往后移动一行，如果成功返回true；否则返回false。
2、getInt(”id“)或getSting(”name“)，返回当前游标下某个字段的值。
3、释放连接。
cn.close();
一般，先关闭ResultSet，然后关闭Statement（或者PreparedStatement）；最后关闭Connection
可滚动、更新的记录集
1、创建可滚动、更新的Statement
Statement sm = cn.createStatement(ResultSet.TYPE_SCROLL_ENSITIVE,ResultSet.CONCUR_READ_ONLY);
该Statement取得的ResultSet就是可滚动的
2、创建PreparedStatement时指定参数
PreparedStatemet ps = cn.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
ResultSet.absolute(9000);
批量更新
1、Statement
Statement sm = cn.createStatement();
sm.addBatch(sql1);
sm.addBatch(sql2);
...
sm.executeBatch()
一个Statement对象，可以执行多个sql语句以后，批量更新。这多个语句可以是、update、等或兼有
2、PreparedStatement
PreparedStatement ps = cn.preparedStatement(sql);
{
ps.setXXX(1,xxx);
...
ps.addBatch();
}
ps.executeBatch();
一个PreparedStatement，可以把一个sql语句，变换参数多次执行，一次更新。
事务的处理
1、关闭Connection的自动提交
cn.setAutoCommit(false);
2、执行一系列sql语句
要点：执行每一个新的sql语句前，上一次执行sql语句的Statement（或者PreparedStatemet）必须先close
Statement sm ;
sm = cn.createStatement( into user...);
sm.executeUpdate();
sm.close();
sm = cn.createStatement(” into corp...);
sm.executeUpdate();
sm.close();
3、提交
cn.commit();
4、如果发生异常，那么回滚
cn.rollback();
[Java数据库编程中的几个常用技巧]
篇2：JAVA编程简历
姓名：李XX性别：男出生日期：1983-07-06
居住地：上海市工作年限：两年移动电话：********
目前年薪：4-5万
[教育经历]
/09-/07河北理工大学计算机科学与技术专业本科
[自我评价]
1.熟练使用SSH框架和常用设计模式熟练应用数据库知识
2.熟悉JDBC,MySQL,Oracle；可以进行用例分析及数据建模，
3.有良好的.开发习惯和设计思路，有较好的学习能力及团队精神，积累了1年多的B/S架构开发经验。
4.有良好的英语文档阅读能力。目标在3年内成为合格的高级软件工程师,希望您能给我这样一个机会展示自己.
求职意向
[希望行业]：计算机软件
目标职能：Java软件工程师及相关职位
[工作经验]
2006/07-/06上海新致软件PG
职责：从事Java、jsp、struts等代码编写；项目测试及日语化。能够阅读，理解日文试样书。日语水平与日语考试3级相当。
2008/06-至今慧桥信息科技有限公司Java软件工程师
职责：参与项目的开发和实施全过程，完成相应阶段文档编制，如分析、设计、编码、测试等。
篇3：数据库编程求职信
尊敬的人力资源部领导：
您好!我叫大学生个人简历网，感谢您在百忙之中查看我的资料。我是新华学校的一名应届毕业生，在校期间，我勤奋努力学习，成绩优异，多次获学校学金，掌握了windows、c语言、pasca、,数据结构、数据库原理等专业基础知识。同时，通过大量的实际操作，我熟练掌握了dos,windows操作系统，并对unix有一定的了解，能够独立Word、Excel、Photoshop等应用等软件，有一定的语言编程基础，在经济信息及计算机应用专业通过三年的学习，我已具备了扎实的专业基础知识功底。
作为一名的学生，我认识到互联网将在未来经济中发挥巨大的作用，所以，业余时间我刻苦自学了很多网络知识。首先，在internet基础应用方面，比如浏览网页，搜索引擎的使用，网上查找，下载所需信息等都很熟练。而且，我还不满足于此，进一步学习了html语言，和，frontpage，dreamweaver等网页编辑软件，firework，flash等网页图形处理软件，可以自如的进行网页编辑。现在我在互联网上，就已经建立了自己的个人主页，并用文件传输协议(ftp)进行维护和。不断的努力使我的网站日趋成熟。
当然一个高素质除了掌握扎实的专业知识，还应该具有丰富的人文知识。我从小热爱文学，广览群书，为我的写作能力奠定了坚实的基础。读书以来，不断参加校内外征文活动，发表过作品数篇。特别在大学期间,被特邀为校报记者,参赛文章多次获得校园文学奖。.此外,在英语的学习方面,我已具备了一定的听,说,写和会话能力,可以用英语进行日常的交流。
未来社会需要的.是理（本文来源于+css+Javascript，会ajax更好)。
当前世界各地持有JavaProgrammer证书的人员供需差距极大，迫使企业不得不用高薪聘请Java程序员。因此，JavaProgrammer的含金量比一般的技术人员要高出很大一块。在美国、加拿大、澳大利亚、新加坡等发达国家和中等发达国家，持有JavaProgrammer认证证书的人年薪均在4-10万美金，而在国JavaProgrammer认证的程序员也有极好的工作机会和很高的薪水。
java软件工程师就业前景其实不是一成不变的，而是随着人们的他的需要而变化的，当我们大量需要的时候往往java软件工程师就业前景就会比较明朗，相反的我们不需要了，那么java软件工程师就业前景还会好吗?我们要做的不是看前景的好坏，而是针对自己展开分析。
更多热门文章推荐：
1.Java就业前景如何
2.就业前景最好的十大专业
3.数控技术未来就业前景怎么样?
4.2016学习IT的就业前景分析
5.20信息管理与信息系统就业前景如何
6.2016年数控技术就业前景怎样?
7.软件工程师的就业前景
8.专业就业率前十的排名
9.数控技术专业毕业生就业前景怎么样?
10.JAVA工程师的就业前景分析
篇5：java 网络编程 面试
1. 读写原始数据，一般采用什么流?( )
A InputStream
B DataInputStream
C OutputStream
D BufferedInputStream
2. 为了提高读写性能，可以采用什么流?( )
A InputStream
B DataInputStream
C BufferedReader
D BufferedInputStream
E OutputStream
F BufferedOutputStream
3. 对各种基本数据类型和String类型的读写，采用什么流?( )
A DataInputStream
B BufferedReader
C PrintWriter
D DataOutputStream
E ObjectInputStream
F ObjectOutputStream
4. 能指定字符编码的I/O流类型是：( )
A Reader
B InputStreamReader
C BufferedReader
D Writer
E PrintWriter
F ObjectInputStream
G ObjectOutputStream
H OutputStreamWriter
5. File类型中定义了什么方法来判断一个文件是否存在?( )
A createNewFile
B renameTo
C
D exists
6. File类型中定义了什么方法来创建一级目录?( )
A createNewFile
B exists
C mkdirs
D mkdir
7. 对文本文件操作用什么I/O流?( )
A FileReader
B FileInputStream
C RandomAccessFile
D FileWriter
8. 在unix服务器www.openlab.com.cn上提供了基于TCP的时间服务应用，该应用使用port为13。创建连接到此服务器的语句是：( )
A Socket s = new Socket(“www.openlab.com.cn”, 13);
B Socket s = new Socket(“www.openlab.com.cn:13”);
C Socket s = accept(“www.openlab.com.cn”, 13);
9. 创建一个TCP客户程序的顺序是：( )
A 获得I/O流
B 关闭I/O流
C 对I/O流进行读写操作
D 建立socket
E 关闭socket
10. 创建一个TCP服务程序的顺序是：( )
A 创建一个服务线程处理新的连接
B 创建一个服务器socket
C 从服务器socket接受客户连接请求
D 在服务线程中，从socket中获得I/O流
E 对I/O流进行读写操作，完成与客户的交互
F 关闭socket
G 关闭I/O流
11. Java UDP编程主要用到的两个类型是：( )
A UDPSocket
B DatagramSocket
C UDPPacket
D DatagramPacket
12. TCP/IP是一种：( )
A 标准
B 协议
C 语言
D 算法
[java 网络编程 面试]
篇6：java编程学习方法有哪些
Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。java编程学习方法有哪些呢?
一.初接触软件技术,先挑技术门槛低的技能方向入手。
如果你完全是个外行，只懂得电脑的一般操作和OFFICE的使用，就先从网页制作开始学习，学习DREAMWEAVER的使用。比如自己设定一个小目标：做个人主页，在纸上画框架，然后用DREAMWEAVER慢慢实现，不会使用，就上网搜教程，最好搜到视频、动画或者带图的教程，通俗易懂。用DREAMWEAVER做网页的同时要对照看代码，再找HTML、CSS、JAVASCRIPT的系统手册。这些手册不要一篇一篇的看，你刚开始只看一个大概，了解能实现什么样的效果，在具体项目中再通过手册查代码命令。
熟悉完前台制作后，要了解脚本语言，比如JSP、PHP、C#之类。自己再设定一个小目标;如留言簿。上网搜源码，下载到本地，一步一步的配置环境变量、启动TOMCAT服务器、部署JSP代码，设置好ACCESS数据库(数据库先从简单的ACCESS开始)。这样做的好处是从整体上了解搭建一个WEB运行环境需要的步骤和环节，利于后期的学习。
数据库软件可以从简单的MYSQL、MSSQL开始，了解一下如何建表结构，查看数据，权限机制就可以，更多的内容等接触实际项目的时候再学习也来得及。学习方式同样的是买一本大而全的教材，先大体翻一遍，或者请技术前辈勾划几个常用的重点内容，其他的使用整体了解一下。
以上学习教程针对WEB开发技术的，如果是做偏底层开发，就不适合了。
二.从实用角度出发来学习.
在学习每一个环节技术时，都要给自己设定一个小功能目标，以目标来驱动自己学习。如果盲目看书、各个技术环节都要去了解，就会对学习产生抵触，结果是什么都学不进去。
大部培训机构和大学里的教学方式就是这样，比如讲JAVA，对初学者讲大通的面向对象思想：继承、接口、抽象类，把JDK所有的包都详细讲一遍，IO流、socket编程、SWING等等，并不说这些不重要，只是对于初学者理解不了这些概念。我比较偏向于先从形象的，容易理解的学起，比如能基于关系型数据库做个单表的增删改查~~
三.找个技术前辈做指导
所谓技术前辈是做过几个实际项目的的开发人员，他们很清楚在实际项目中最常用的技术是哪些，哪些开源项目好用。
找到技术前辈并不是帮你解决几行代码调试不通的问题，关键是帮你介绍一两本入门的书、介绍一些网上好的资源网站、指导学习哪些常用类、遇到麻烦的技术难点用什么开源组件等等。
有个好师傅非常非常的重要!! 让你少走很多弯路。
四.脸皮要厚,不怕被人笑话
刚开始做技术，进入软件公司工作，就很不自信，总觉得自己这也不知道，那也不了解。其实，没关系，你要对自己树立信心，你要明白一点：所有的技术都没什么难度，都是熟能生巧的过程。 所以，一遇到问题就赶紧问老开发人员，平时上下班，吃饭时多跟他们聊;业务上不懂的就问项目经理和需求分析员，没什么关系的。
我再讲个极端一点的情况，我个人刚学技术时，头两家公司都是把我开掉的，为什么呢?因为我那时水平确实太差了。 但每一次公司工作的机会都让我进了一步。后来遇到几个同行，有好几个人也有同样被开除的经历。为了学习技术，就别担心面子的问题了。
在外打工，遇到的同事在你人生过程之中都是过客，没有人会把你某段代码不会写当成笑话记一辈子的。坦城、自信很重要!
五.在打工过程中多长心眼,除技术外,想积累人脉.技能.项目经验
我们不能做一辈子程序员，以后总要升级转行，做项目经理、做售前、或者是公司高管。但这些都需要前期的积累。你在打工过程中，除了挣钱，还要积累技术、积累人脉关系，包括与技术和销售同事之间(以后做项目，遇到技术难点得找人问;或者同事以后接到项目要找人合作说不准就想到你了)、与客户之间的(这个很重要)，积累项目经验，主要是学习各个行业的业务知识，象电信、金融、电力、ERP等。如果你进了某个行业，比如电信、电力，你再跳槽就最好别换行业了。
篇7：java面试编程题
1.现在输入n个数字，以逗号，分开;然后可选择升或者降序排序;按提交键就在另一页面显示按什么排序，结果为，提供reset
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:\\03月份”);
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/20070114/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面试编程题]
