Java笔试之编程题库

1.编程实现：二分搜索算法 解答：

public class SearchTest { /** 被搜索数据的大小 */

private static final int size = 5000000; public static void main(String[] args) { long[] data = new long[size]; // 添加测试数据

for (int k = 0; k < data.length; k++) { data[k] = k; }

// 要查找的数据 long target = 4970002; binaryFindTest(data, target); } /**

* 二分搜索算法实现 *

* @param data * 数据集合 * @param target * 搜索的数据

* @return 返回找到的数据的位置，返回-1表示没有找到。 */

public static int binaryFind(long[] data, long target) { int start = 0;

int end = data.length – 1; while (start <= end) {

int middleIndex = (start + end) / 2; if (target == data[middleIndex]) { return middleIndex; }

if (target >= data[middleIndex]) { start = middleIndex + 1;

} else {

end = middleIndex – 1; } } return -1; } /**

* 二分搜索测试 *

* @param data * 数据集合 * @param target * 搜索的数据 */

public static void binaryFindTest(long[] data, long target) { long start = System.nanoTime(); int result = binaryFind(data, target); long end = System.nanoTime();

System.out.println(“binary search position：” + result); System.out.println(“binary search time：” + (end – start)); } }

2.编程实现：线程A向队列Q中不停写入数据，线程B从队列Q中不停读取数据（只要Q中有数据）。 解答：

接口中有两个一个是向队列中写push方法 一个是从队列中读。 public interface StackInterface {

public void push(int n); public int[] pop(); }

上边接口的实现类。

public class SafeStack implements StackInterface { private int top = 0;

private int[] values = new int[10]; private boolean dataAvailable = false; public void push(int n) {

synchronized (this) { while (dataAvailable) // 1 { try { wait();

} catch (InterruptedException e) { // 忽略 //2 } }

values[top] = n;

System.out.println(“压入数字” + n + “步骤1完成”); top++;

dataAvailable = true; notifyAll();

System.out.println(“压入数字完成”); } }

public int[] pop() { synchronized (this) { while (!dataAvailable) // 3 { try { wait();

} catch (InterruptedException e) { // 忽略 //4 } }

System.out.print(“弹出”); top–;

int[] test = { values[top], top }; dataAvailable = false;

// 唤醒正在等待压入数据的线程 notifyAll(); return test; } } }

读线程

public class PopThread implements Runnable {

private StackInterface s;

public PopThread(StackInterface s) { this.s = s; }

public void run() {

while(true) {

System.out.println(“->”+ s.pop()[0] + “<-”); try {

Thread.sleep(100); }

catch(InterruptedException e){} } } } 写线程

public class PushThread implements Runnable {

private StackInterface s;

public PushThread(StackInterface s) { this.s = s; }

public void run() { int i = 0; while(true) {

java.util.Random r = new java.util.Random(); i = r.nextInt(10); s.push(i); try {

Thread.sleep(100); }

catch(InterruptedException e){} } } }

3.编程实现：使用Socket经行网络通信时，客户端和服务器端流程。 解答：

服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于1024以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于1024的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。

客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个1024以上的端口。

4.编写代码实现同一平面内两圆是否碰撞，其中：

第一个圆圆心坐标为(x1,y1)，半径是r1，第二个圆圆心坐标为(x2,y2)，半径是r2。 方法声明如下：

boolean collisWith(int x1,int y1,int r1,int x2,int y2,int r2){} 解答：

boolean collisWith(int x1, int y1, int r1, int x2, int y2, int r2) { boolean flag=false; int num1=(x1-x2)*(x1-x2); int num2=(y1-y2)*(y1-y2); int num3=num1+num2;

double distance=Math.sqrt(num3); if(distance<=（r1+r2）){ flag=true; }

return flag; }

5.判断一个int数组中的元素是否存在重复，方法声明如下： boolean isRepeat(int[] m){ } 解答：

public boolean isRepeat2(int[] m){ Set h =new HashSet(m.length); for (int i = 0; i < m.length; i++) { h.add(new Integer(m[i])); } if (h.size()==m.length ){ return false; }else { return true; } }

6.用递归方法实现正序显示数组元素。例如String[] s = {“a”,”b”,”c”,”d”};

方法声明如下：

void print(String[] s,int i){ }

解答：参数 i 是指打印string数组的起始位置，原理是正序打印s从第0个开始的所有字符串，等价于先打印第0个，在打印s中从第一个开始的所有字符串，如此递归 void print(String[] s, int i) { if ((i >= 0) && (i < s.length)) { System.out.print(s[i]); i++; print(s, i); } }

7.请写出求n！的算法。 解答：

public class Factorial {

public static void main(String[] args) { long n = 6;

System.out.println(doFactorial(n)); }

public static long doFactorial(long n) { if (n < 1) {

System.out.println(“ERROR”); return 0;

} else if (n == 1 || n == 2) { return n; } else {

return n * doFactorial(n – 1); } } }

8.在当前的JSP网页里，提交用户名和密码，提交给post . jsp, post . jsp打印出用户名和密码并返回给浏览器。请写出post . jsp 解答：

假设页面用户名和密码在login.jsp里，login.jsp页面代码如下：

post.jsp页面代码： <%

String userName=request.getParameter(“userName”); String pwd=request.getParameter(“pwd”);

out.println(“用户名：”+userName+”,密码：”+pwd); %>

9.编写一个字符界面的Java Application 程序，接受用户输入的10个整数，并输出这10个整数的最大值和最小值。 解答：采用了冒泡进行排序 import java.util.Scanner; import java.util.Scanner; public class MaxAndMin {

public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int[] arr = new int[10];

for (int i = 0; i < arr.length; i++) { int next = scanner.nextInt(); arr[i] = next; }

int[] after=Arrays.sort(arr);

System.out.println(“最小值：”+after[0]+”,最大值：”+after[arr.length-1]); } }

10.写一个排序算法 1-100随机数字 进行排序 要求效率。 解答：

public class Sort { // 选择排序方法

public static void selectionSort(int[] number) { for (int i = 0; i < number.length – 1; i++) { int m = i;

for (int j = i + 1; j < number.length; j++) { if (number[j] < number[m]) m = j; } if (i != m)

swap(number, i, m);

} }

// 用于交换数组中的索引为i、j的元素

private static void swap(int[] number, int i, int j) { int t; t = number[i]; number[i] = number[j]; number[j] = t; }

public static void main(String[] args) { // 定义一个数组 int[] num = new int[100]; for(int i=0;iselectionSort(num);

for (int i = 0; i < num.length; i++) { System.out.println(num[i]); } } }

11.冒泡排序:依次比较相邻的两个数,将大数放在前面,小数放在后面。第一趟结束,在最后的数必是所有数中的最小数。重复以上过程,直至最终完成排序。由于在排序过程中总是大数往前放,小数往后放,相当于气泡往上升,所以称作冒泡排序。请用JAVA语言编写一个完成冒泡排序算法的程序。 解答:

int[] bubbleSort(int before[]) { int t;

for (int i = 0; i < before.length; i++) { for (int j = 0; j < before.length – i – 1; j++) { if (before[j] > before[j + 1]) { t = before[j];

before[j] = before[j + 1]; before[j + 1] = t; } }

}

return before; }

12.写出一段socket通讯（客户端）的代码，功能描述如下：

a)客户端发起socket通讯，报文结构为报文号（3位）+用户名（5位）+密码（8位）+ 结束符（固定为END）。此处报文号为100

b)服务端收到后返回应答报文，报文结构为报文号（3位）+验证结果（2位）+结束符（固定为END）。此处报文号为101

c)Socket服务器ip为192.168.0.2，端口号为9999 解答： 客户端代码：

Socket sk = new Socket(“192.168.0.2″,9999); OutputStream os = sk.getOutputStream(); PrintWriter pw = new PrintWriter(os,true); pw.write(“100stone888888END”); pw.close(); sk.close(); 服务器端代码：

ServerSocket vk = new ServerSocket(9999); Socket sk = vk.accept();

OutputStream os = sk.getOutputStream(); PrintWriter pw = new PrintWriter(os,true); pw.write(“101oldEND”); pw.close(); sk.close();

13.编写函数insert(String str)，将字符串”a,123;b,456;c,789”置入HashMap中。 解答：

import java.util.HashMap; public class HashMapDemo {

HashMap map=new HashMap(); public void insert(String str){ map.put(“a”, str); }

public static void main(String[] args) { HashMapDemo demo=new HashMapDemo(); demo.insert(“a,123;b,456;c,789″); }

}

14.有一数组 a[1000]存放了1000 个数,这 1000个数取自1-999, 且只有两个相同的数,剩下的 998个数不同, 写一个搜索算法找出相同的那个数的值（请用 C# or JAVA编程实现，注意空间效率和时间效率尽可能优化）。 解答：

import java.util.Arrays; public class SearchDemo { /** 被搜索数据的大小 */

private static final int size = 1000; public static void main(String[] args) { int[] data = new int[size]; // 添加测试数据

for (int k = 0; k < data.length; k++) { data[k] = k + 1; }

data[999] = 567; result(data); } /**

* 调用分搜索算法的方法实现查找相同元素 * @param data */

public static void result(int data[]){ Arrays.sort(data);

for (int i = 0; i < data.length; i++) { int target = data[i]; data[i] = 0;

int result = binaryFind(data, target); if (result != -1) {

System.out.println(“相同元素为：”+data[result]); break; } } } /**

* 二分搜索算法实现 *

* @param data * 数据集合 * @param target * 搜索的数据

* @return 返回找到的数据的位置，返回-1表示没有找到。 */

public static int binaryFind(int[] data, int target) { int start = 0;

int end = data.length – 1; while (start <= end) {

int middleIndex = (start + end) / 2; if (target == data[middleIndex]) { return middleIndex; }

if (target >= data[middleIndex]) { start = middleIndex + 1; } else {

end = middleIndex – 1; } } return -1; } }

15.下面是一个由*号组成的4行倒三角形图案。要求：1、输入倒三角形的行数，行数的取值3-21之间，对于非法的行数，要求抛出提示“非法行数！”；2、在屏幕上打印这个指定了行数的倒三角形。 ******* ***** *** * 解答：

import java.util.Scanner; public class Lines {

public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int lines = scanner.nextInt(); if (lines > 3 && lines < 21) {

for (int i = lines-1; i >= 0; i–) { for (int z = 0; z <= i * 2; z++) { System.out.print(“*”); }

System.out.print(“\\n”); } }else{

System.out.println(“非法行数！”); } } }

16.现有一个32位的整型变量 value和一个有32个元素的数组a[32]，要求：1、对value随机赋值；2、让数组a[n]的值等于value“位n”的值，0<=n<=31。举例：如果value的“位0”(Bit0)=0，那么a[0]=0；如果value的“位10”(Bit10)=1，那么a[10]=1。 解答：

public class Foo {

public static void main(String[] args) { //产生随机数

int random = (int) (Math.random() * Integer.MAX_VALUE + 1); //转成二进制字符串

String str=Integer.toBinaryString(random); //转成二进制时最前面的零被省略，补上省略的0 if(str.length()<32){

for(int j=0;j<=32-str.length();j++){ str=”0″+str; } }

//给数组赋值 int[] a=new int[32];

for(int i=0;ia[i]=Integer.parseInt(String.valueOf(str.charAt(i))); System.out.println(“a[\"+i+\"]=”+a[i]); } } }

17.现有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); 18. 实现函数public String[ ] array(List list)，其中参数list中元素类型为字符串 解答：

public String[] array(List list) {

String[] elementData = new String[list.size()]; for(int i=0;ireturn elementData ; }

19．创建类Person，其中存储的成员数据为:age(int),sex(boolean),weight(int)，至少有一个构造函数可以初始化这三个属性值，同时提供获取这三个属性值的public方法 解答：

public class Person { private int age; private boolean sex; private int weight; public Person() { }

public Person(int age, boolean sex, int weight) { this.age = age; this.sex = sex; this.weight = weight; }

public int getAge() { return age; }

public boolean isSex() { return sex; }

public int getWeight() { return weight; } }

20．设计线程类WorkerThread，其构造函数接受一个message字符串作为参数，把该字符串打印到console上，同时，在WorkThread的main函数中启动该线程。 解答：

public class WorkerThread extends Thread { public WorkerThread(String message) { System.out.println(message); }

public static void main(String[] args) { new WorkerThread(“hello world!”).start(); } }

21.写一个函数去掉一个字符串中单词间多余的空格，使得相邻两个单词间有且只有一个空格。例如当输入字符串是“Hello!_ _Game_programming_ _world!”时，调用该函数后字符串变为“Hello!_Game_programming_world!”。 解答： /**

* 去除字符串中多余的空格 *

* @param s * 需要处理的字符串 * @return 处理后的字符串 */

public String trimSpace(String before) { String temp= “” + before.charAt(0); for (int i = 1; i < before.length(); i++) { char c = before.charAt(i); // 如果当前字符是空格 if (c == ‘ ‘) {

// 判断前一个不是是空格则添加，否则不添加 if (before.charAt(i – 1) != ‘ ‘) { temp += c; } } else { temp += c; } }

return temp;

}

22. 编写一个程序，用来计算1到100间所有整数的和是多少？ 解答：

public static void GetSum() {

int sum = 0;

for(int i=1;i<=100;i++) { sum+=i; }

System.out.println(“和为：”+sum); }

23.请简单写出用JAVA连接Oracle数据库，并执行一条/SQL语句。（只需要写关键几条语句即可，/SQL语句：SELECT*FROM t_users WHERE users_id=‘1111’） 解答：

Class.forName(“oracle.jdbc.OracleDriver”); String url = “jdbc:oracle:thin:@127.0.0.1:1521:orcl”; String user = “scott”; String password = “tiger”;

Connection con = DriverManager.getConnection(url, user, password); Statement stm = con.createStatement(); ResultSet rs = stm

.executeQuery(“SELECT*FROM t_users WHERE users_id=’1111′”); while (rs.next()) { // 取值 }

rs.close(); stm.close(); con.close();

24.在web应用开发过程中经常遇到输出某种编码的字符，如从GBK到iso8859-1等，如何输出一个某种编码的字符串？

public static String translate(String str) { String tempStr = “”; try {

tempStr = new String(str.getBytes(“ISO-8859-1″), “GBK”); tempStr = tempStr.trim(); } catch (Exception e) {

System.err.println(e.getMessage()); }

return tempStr; }

25. 请写出一个公用方法，输入String返回该串是否含有非空字符,并写出junit的测试用例 答：

public class TestString {

public static boolean hasBlank(String str) { if (str.endsWith(“”) || str.startsWith(“”)) { return false; } else {

String[] strs = str.split(“”); if (strs.length == 1) { return false; } }

return true; } @Test

public void testFun() {

System.out.println(TestString.hasBlank(“test”)); } }

26. 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;ilist.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;itempInt = (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;jif (((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;iSystem.out.println(“list[\"+i+\"]=”+list.get(i)); } }

public static void main(String[] args) {

InsertSort sort = new InsertSort(10,100); sort.SortIt(); } }

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

package com.tarena; public class SplitString { String SplitStr; int SplitByte;

public SplitString(String str, int bytes) { SplitStr = str; SplitByte = bytes;

System.out.println(“The String is:” + SplitStr + “;SplitBytes=” + SplitByte); }

public void SplitIt() {

int loopCount;

loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.length()/SplitByte+1);

System.out.println(“Will Split into “+loopCount); for (int i=1;i<=loopCount ;i++ ) {

if (i==loopCount){

System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length())); } else {

System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte))); } }

} public static void main(String[] args) { SplitString ss = new SplitString(

“test中dd文dsaf中男大3443n中国43中国人0ewldfls=103″, 4);

ss.SplitIt(); } }

28. 编写程序将由数字及字符组成的字符串中的数字截取出来并按顺序输出，例如：“ABC137GMNQQ2049PN5FFF”输出结果应该为01234579 答：

package com.tarena; import java.util.Arrays; public class NumberSplitChar { public static void main(String[] args) {

String str=”ABC137GMNQQ2049PN5FFF”; char[] beforechars=str.toCharArray();

char[] afterchars=new char[beforechars.length]; int j=0;

for(int i=0;iif(beforechars[i]>=’0′ && beforechars[i]<=’9′){ afterchars[j++]=beforechars[i]; } }

Arrays.sort(afterchars);

for(int i=(afterchars.length-j);i29. 请用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[tail]; tail–; return tmp; } else {

System.err.println(“队列为空！”);

throw new RuntimeException(); } } }

30. 假定屏幕的像素宽度为screenWidth，写一个函数计算一个字符串需要分成几行显示。 要求：

1）、每行应尽可能多地显示字符，但不能有字符部分或完全显示在屏幕外。超过部分的字符换下一行显示。

2）、每个字符的像素宽度不一样，每个字符的像素宽度不一样。用int GetCharWidth(char c)获得每个字符的像素宽度。 /**

* 计算一个字符串可以分多少行进行显示 *

* @param s * 原始字符串

* @param screenWidth * 屏幕宽度 * @return 行数 */

int calcLineNum(String s, int screenWidth) { int length = 0; // 行数 int n = 0; // 统计长度

for (int i = 0; i < s.length(); i++) { // 当前字符的宽度

int charLen = GetCharWidth(s.charAt(i)); // 总长度增加 length += charLen; // 如果达到屏幕宽度 if (length > screenWidth) { n++; // 行数+1

length = charLen; // 重新计算长度 } }

// 最后一行处理 if (length > 0) {

n++; } return n; }