当前位置：首页 > 面试问题>JAVA经典算法面试10题及答案

JAVA经典算法面试10题及答案

2022-06-16 08:14:07 收藏本文下载本文

“你与氧气并存i”通过精心收集，向本站投稿了10篇JAVA经典算法面试10题及答案，下面是小编为大家整理后的JAVA经典算法面试10题及答案，如果喜欢可以分享给身边的朋友喔!

JAVA经典算法面试10题及答案

篇1：JAVA经典算法面试10题及答案

JAVA经典算法面试10题及答案

【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21….

public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); }}或public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math; for(i=1;i<=20;i++) System.out.println(mymath.f(i)); }}class math{ public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); }}

【程序2】题目：判断101-200之间有多少个素数，并输出所有素数，

1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，

则表明此数不是素数，反之是素数。

public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); }}class math{ public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; }}

【程序3】题目：打印出所有的 “水仙花数 “，所谓 “水仙花数 “是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 “水仙花数 “，因为153=1的三次方＋5的三次方＋3的三次方。

1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=100;i<=999;i++) if(mymath.shuixianhua(i)==true) System.out.println(i); }}class math{ public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; } public boolean shuixianhua(int x) { int i=0,j=0,k=0; i=x / 100; j=(x % 100) /10; k=x % 10; if(x==i*i*i+j*j*j+k*k*k) return true; else return false; }}

【程序4】题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：

(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。

(2)如果n k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你,重复执行第一步。

(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。

public class exp2{ public exp2(){} public void fengjie(int n){ for(int i=2;i<=n/2;i++){if(n%i==0){ System.out.print(i+“*”); fengjie(n/i); } } System.out.print(n); System.exit(0);///不能少这句，否则结果会出错 } public static void main(String[] args){ String str=“”; exp2 c=new exp2(); str=javax.swing.JOptionPane.showInputDialog(“请输入N的值（输入exit退出）：”); int N; N=0; try{ N=Integer.parseInt(str); }catch(NumberFormatException e){ e.printStackTrace(); }System.out.print(N+“分解质因数：”+N+“=”);c.fengjie(N); } }

【程序5】题目：利用条件运算符的嵌套来完成此题：学习成绩> =90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

1.程序分析：(a> b)?a:b这是条件运算符的基本例子。

import javax.swing.*;public class ex5 { public static void main(String[] args){ String str=“”; str=JOptionPane.showInputDialog(“请输入N的值（输入exit退出）：”); int N; N=0; try{ N=Integer.parseInt(str); } catch(NumberFormatException e){ e.printStackTrace(); } str=(N>90?“A”:(N>60?“B”:“C”)); System.out.println(str); } }

【程序6】题目：输入两个正整数m和n，求其最大公约数和最小公倍数，

1.程序分析：利用辗除法。

最大公约数：public class CommonDivisor{ public static void main(String args[]) { commonDivisor(24,32); } static int commonDivisor(int M, int N) { if(N<0||M<0) {System.out.println(“ERROR!”);return -1; } if(N==0) {System.out.println(“the biggest common divisor is :”+M);return M; } return commonDivisor(N,M%N); }}最小公倍数和最大公约数：import java.util.Scanner; public class CandC { //下面的方法是求出最大公约数public static int gcd(int m, int n) { while (true) { if ((m = m % n) == 0) return n; if ((n = n % m) == 0) return m; } } public static void main(String args[]) throws Exception { //取得输入值//Scanner chin = new Scanner(System.in); //int a = chin.nextInt(), b = chin.nextInt(); int a=23; int b=32;int c = gcd(a, b); System.out.println(“最小公倍数：” + a * b / c + “n最大公约数：” + c); } }

【程序7】题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

1.程序分析：利用while语句,条件为输入的.字符不为 ‘n ‘.

import java.util.Scanner;public class ex7 { public static void main(String args[]) { System.out.println(“请输入字符串：”); Scanner scan=new Scanner(System.in); String str=scan.next(); String E1=“[u4e00-u9fa5]”; String E2=“[a-zA-Z]”; int countH=0; int countE=0; char[] arrChar=str.toCharArray(); String[] arrStr=new String[arrChar.length]; for (int i=0;i

【程序8】题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。

1.程序分析：关键是计算出每一项的值。

import java.io.*;public class Sumloop { public static void main(String[] args) throws IOException { int s=0; String output=“”; BufferedReader stadin = new BufferedReader(new InputStreamReader(System.in)); System.out.println(“请输入a的值”); String input =stadin.readLine(); for(int i =1;i<=Integer.parseInt(input);i++) { output+=input; int a=Integer.parseInt(output); s+=a; } System.out.println(s); }}另解:import java.io.*;public class Sumloop { public static void main(String[] args) throws IOException { int s=0; int n; int t=0; BufferedReader stadin = new BufferedReader(new InputStreamReader(System.in)); String input = stadin.readLine(); n=Integer.parseInt(input); for(int i=1;i<=n;i++){ t=t*10+n; s=s+t; System.out.println(t); } System.out.println(s); }}

【程序9】题目：一个数如果恰好等于它的因子之和，这个数就称为 “完数 “。例如6=1＋2＋3.编程找出1000以内的所有完数。

public class Wanshu { public static void main(String[] args) { int s; for(int i=1;i<=1000;i++) { s=0; for(int j=1;j

【程序10】题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

public class Ex10 { public static void main(String[] args) { double s=0; double t=100; for(int i=1;i<=10;i++) { s+=t; t=t/2; } System.out.println(s); System.out.println(t); }}

篇2：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: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面试编程题]

篇3：JAVA面试精选[Java算法与编程一]

1、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔，

答：

packagecn.itcast;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

public class MainClass{

public static voidmain(String[] args) throws Exception{

FileManager a= new FileManager(“a.txt”,new char[]{'n'});

FileManager b= new FileManager(“b.txt”,new char[]{'n',' '});

FileWriter c= new FileWriter(“c.txt”);

String aWord= null;

String bWord= null;

while((aWord= a.nextWord) !=null ){

c.write(aWord+ “n”);

bWord= b.nextWord();

if(bWord!= null)

c.write(bWord+ “n”);

}

while((bWord= b.nextWord()) != null){

c.write(bWord+ “n”);

}

c.close();

}

class FileManager{

String[] words =null;

int pos = 0;

publicFileManager(String filename,char[] seperators) throws Exception{

File f = newFile(filename);

FileReaderreader = new FileReader(f);

char[] buf =new char[(int)f.length()];

int len =reader.read(buf);

Stringresults = new String(buf,0,len);

String regex= null;

if(seperators.length>1 ){

regex= “” + seperators[0] + “|” + seperators[1];

}else{

regex= “” + seperators[0];

}

words =results.split(regex);

}

public StringnextWord(){

if(pos ==words.length)

returnnull;

returnwords[pos++];

}

2、编写一个程序，将d:java目录下的所有.java文件复制到d:jad目录下，并将原来文件的扩展名从.java改为.jad。

（大家正在做上面这道题，网上迟到的朋友也请做做这道题，找工作必须能编写这些简单问题的代码！）

答：listFiles方法接受一个FileFilter对象，这个FileFilter对象就是过虑的策略对象，不同的人提供不同的FileFilter实现，即提供了不同的过滤策略。

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

public class Jad2Java {

public static voidmain(String[] args) throws Exception {

File srcDir =new File(“java”);

if(!(srcDir.exists()&& srcDir.isDirectory()))

thrownew Exception(“目录不存在”);

File[] files= srcDir.listFiles(

newFilenameFilter(){

publicboolean accept(File dir, String name) {

returnname.endsWith(“.java”);

}

);

System.out.println(files.length);

File destDir= new File(“jad”);

if(!destDir.exists())destDir.mkdir();

for(File f:files){

FileInputStream fis = new FileInputStream(f);

StringdestFileName = f.getName().replaceAll(“.java$”, “.jad”);

FileOutputStreamfos = new FileOutputStream(new File(destDir,destFileName));

copy(fis,fos);

fis.close();

fos.close();

}

private static voidcopy(InputStream ips,OutputStream ops) throws Exception{

int len = 0;

byte[] buf =new byte[1024];

while((len =ips.read(buf)) != -1){

ops.write(buf,0,len);

}

由本题总结的思想及策略模式的解析：

class jad2java{

1. 得到某个目录下的所有的java文件集合

1.1 得到目录 File srcDir = newFile(“d:java”);

1.2 得到目录下的所有java文件：File[] files =srcDir.listFiles(new MyFileFilter());

1.3 只想得到.java的文件： class MyFileFilterimplememyts FileFilter{

publicboolean accept(File pathname){

returnpathname.getName().endsWith(“.java”)

}

2.将每个文件复制到另外一个目录，并改扩展名

2.1 得到目标目录，如果目标目录不存在，则创建之

2.2 根据源文件名得到目标文件名，注意要用正则表达式，注意.的转义，

2.3 根据表示目录的File和目标文件名的字符串，得到表示目标文件的File。

//要在硬盘中准确地创建出一个文件，需要知道文件名和文件的目录。

2.4 将源文件的流拷贝成目标文件流，拷贝方法独立成为一个方法，方法的参数采用抽象流的形式。

//方法接受的参数类型尽量面向父类，越抽象越好，这样适应面更宽广。

}

分析listFiles方法内部的策略模式实现原理

File[] listFiles(FileFilter filter){

File[] files =listFiles();

//ArraylistacceptedFilesList = new ArrayList();

File[] acceptedFiles= new File[files.length];

int pos = 0;

for(File file:files){

booleanaccepted = filter.accept(file);

if(accepted){

//acceptedFilesList.add(file);

acceptedFiles[pos++]= file;

}

Arrays.copyOf(acceptedFiles,pos);

//return(File[])accpetedFilesList.toArray();

}

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

答：

首先要了解中文字符有多种编码及各种编码的特征。

假设n为要截取的字节数。

public static voidmain(String[] args) throws Exception{

String str =“我a爱中华abc我爱传智def';

String str =”我ABC汉“;

int num =trimGBK(str.getBytes(”GBK“),5);

System.out.println(str.substring(0,num));

}

public staticint trimGBK(byte[] buf,int n){

int num = 0;

booleanbChineseFirstHalf = false;

for(inti=0;i< p=”“>

{

if(buf[i]<0&& !bChineseFirstHalf){

bChineseFirstHalf= true;

}else{

num++;

bChineseFirstHalf= false;

}

return num;

}

4、有一个字符串，其中包含中文字符、英文字符和数字字符，请统计和打印出各个字符的个数。

答：哈哈，其实包含中文字符、英文字符、数字字符原来是出题者放的烟雾弹。

String content = “中国aadf的111萨bbb菲的zz萨菲”;

HashMap map = new HashMap();

for(int i=0;i< p=”“>

{

char c =content.charAt(i);

Integer num =map.get(c);

if(num == null)

num = 1;

else

num = num +1;

map.put(c,num);

}

for(Map.EntrySet entry : map)

{

system.out.println(entry.getkey()+ “:” + entry.getValue());

}

估计是当初面试的那个学员表述不清楚，问题很可能是：

如果一串字符如”aaaabbc中国1512“要分别统计英文字符的数量，中文字符的数量，和数字字符的数量，假设字符中没有中文字符、英文字符、数字字符之外的其他特殊字符。

int engishCount;

int chineseCount;

int digitCount;

for(int i=0;i< p=”“>

{

篇4：java面试问题及答案

1、作用域public,private,protected,以及不写时的区别

答：区别如下：

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

public √ √ √ √

protected √ √ √ ×

friendly √ √ × ×

private √ × × ×

不写时默认为friendly

2、arraylist和vector的区别,hashmap和hashtable的区别

答：就arraylist与vector主要从二方面来说.

一.同步性:vector是线程安全的，也就是说是同步的，而arraylist是线程序不安全的，不是同步的

二.数据增长:当需要增长时,vector默认增长为原来一培，而arraylist却是原来的一半

就hashmap与hashtable主要从三方面来说。

一.历史原因:hashtable是基于陈旧的dictionary类的，hashmap是java 1.2引进的map接口的一个实现

二.同步性:hashtable是线程安全的，也就是说是同步的，而hashmap是线程序不安全的，不是同步的

三.值：只有hashmap可以让你将空值作为一个表的条目的key或value

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

答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

答：多线程有两种实现方法，分别是继承thread类与实现runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify

篇5：java面试问题及答案

1)transient和volatile是java关键字吗?(瞬联)

如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。例如：

class t

{

transient int a; //不需要维持

int b; //需要维持

}

这里，如果t类的一个对象写入一个持久的存储区域，a的内容不被保存，但b的将被保存。

volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。在多线程程序中，有时两个或更多的线程共享一个相同的实例变量。考虑效率问题，每个线程可以自己保存该共享变量的私有拷贝。实际的变量副本在不同的时候更新，如当进入synchronized方法时。用strictfp修饰类或方法，可以确保浮点运算(以及所有切断)正如早期的java版本那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰，所有的方法自动被strictfp修饰。

strictfp的意思是fp-strict，也就是说精确浮点的意思。在java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内java的编译器以及运行环境会完全依照浮点规范ieee-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码：

strictfp interface a {}

public strictfp class fpdemo1 {

strictfp void f {}

}

2. 错误的使用方法

interface a {

strictfp void f();

}

public class fpdemo2 {

strictfp fpdemo2() {}

}

一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合ieee-754规范

的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。

2)抽象类和接口有什么区别?(瞬联)

1.abstract class 在 java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员(也就是必须是static final的，不过在 interface中一般不定义数据成员)，所有的成员方法都是abstract的。

3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是”is-a“关系，interface表示的是”like-a“关系。

4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

7.接口中的方法默认都是 public,abstract 类型的。

3)能说一下java的反射(reflection)机制吗?(瞬联)

开放性和原因连接(causally-connected)是反射系统的两大基本要素

4)在java中怎样实现多线程?(瞬联)

extends thread

implement runnable

方法一：继承 thread 类，覆盖方法 run()，我们在创建的 thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：

public class mythread extends thread

{

int count= 1, number;

public mythread(int num)

{

number = num;

system.out.println

(”创建线程 “ + number);

}

public void run() {

while(true) {

system.out.println

(”线程 “ + number + ”:计数 “ + count);

if(++count== 6) return;

}

public static void main(string args[])

{

for(int i = 0;i 〈 5; i++) new mythread(i+1).start();

}

这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承(如小程序必须继承自 applet 类)，则无法再继承 thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢?

我们不妨来探索一种新的方法：我们不创建thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 thread 类的实例，有点类似回调函数。但是 java 没有指针，我们只能传递一个包含这个方法的类的实例。

那么如何限制这个类必须包含这一方法呢?当然是使用接口!(虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗?)

java 提供了接口 java.lang.runnable 来支持这种方法。

方法二：实现 runnable 接口

runnable接口只有一个方法run()，我们声明自己的类实现runnable接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是runnable接口并没有任何对线程的支持，我们还必须创建thread类的实例，这一点通过thread类的构造函数 public thread(runnable target);来实现。下面是一个例子：

public class mythread implements runnable

{

int count= 1, number;

public mythread(int num)

{

number = num;

system.out.println(”创建线程 “ + number);

}

public void run()

{

while(true)

{

system.out.println

(”线程 “ + number + ”:计数 “ + count);

if(++count== 6) return;

}

public static void main(string args[])

{

for(int i = 0; i 〈 5;i++) new thread(new mythread(i+1)).start();

}

严格地说，创建thread子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现runnable 接口的类的 run 方法，对此大家不妨试验一下。

使用 runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 thread 来得紧凑。

综上所述，两种方法各有千秋，大家可以灵活运用。

下面让我们一起来研究一下多线程使用中的一些问题。

三、线程的四种状态

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(单态模式)

保证一个类只有一个实例,并提供一个访问它的全局访问点 /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：java面试问题及答案

1.J2EE是什么?(Java 2 Enterprise Edition, 中文为Java 2企业版本，由多种技术组成，主要的两大技术为Servlet技术和EJB技术，J2EE程序需要在J2EE容器内运行)

2.介绍JAVA中的Collection FrameWork(Java的Collection FrameWork包括两大接口，为Collection和Map。5.0版本增加了一个新的接口Queue。其中Collection又包括List和Set接口。其所有的标准实现类均在java.util包中定义。总体上来说，Map定义了键和值的对应关系，List定义了列表，Set定义了堆式。所以一般来说Map和Set为无序而List有序，但也有例外。)?

如COLLECTION中遗留类(HASHTABLE、VECTOR)和现有类的区别?(同步) 3.Java中异常处理机制，事件机制?

所有继承自Trowable的类的对象都可被抛出和捕获，继承它的Error接口表示错误，而Exception表示异常，继承自Exception下RuntimeException接口的类表示运行时异常，可以不被捕获。事件则一般采用接口来实现，接口内定义回调方法而实现该接口的类定义具体流程。

4.EJB与JAVA BEAN的区别?

EJB与JAVA BEAN是SUN的不同组件规范，EJB是在容器中运行的，分步式的，而JAVA BEAN主要是一种可利用的组件，主要在客户端UI表现上。

5.JAVA中的多形与继承?

可出编程，选择题。

6.抽象类与接口?

接口的好处是将实现与表现分离。

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

7.Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示?

8.JAVA SERVLET API中forward() 与redirect()的区别?

forward()是在容器内部对请求的转发，而redirect()使用的是HTTP协议在应答中将客户端

重新定向至所指定的URL。使用forward()时客户端不产生新的请求，而使用redirect()时客户端会产生一个新的请求。

9.JAVA解析XML的方式? SAX、DOM

10.用JAVA实现数据库查询，这是一道编程题。

11.用JAVA实现一种排序，比较，JAVA类实现序列化的方法(二种)?

如在COLLECTION框架中，实现比较要实现什么样的接口。

12.JSP中动态INCLUDE与静态INCLUDE的区别? 动态可以带参数，静态相当于一段静态HTML文件。

13.应用服务器与WEB SERVER的区别?

应用服务器侧重于对应用流程的实现，WEB SERVER侧重于对网络协议的实现。

14.设计模式与UML方面。

如工厂模式，解决多数据库支持问题。

15。编程：编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。

但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。

16。在ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。 17。WEB SERVICE名词解释。JSWDL开发包的介绍。JAXP、JAXM的解释。SOAP、UDDI解释。 18。BS与CS的联系与区别。 19。LINUX下线程，GDI类的解释。 20。JAVA多线程编程。

用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。 21。JAVA的基本功： STRING与STRINGBUFFER的区别。

22。STRUTS的应用(如STRUTS架构

JAVA方面

1 面向对象的特征有哪些方面继承，多态，抽象，重载, 封装 2 String是最基本的数据类型吗? 不是

3 int 和 Integer 有什么区别一个是基本类型，另一个是对象 4 String 和StringBuffer的区别一个是非可变类，另一个是可变类 5运行时异常与一般异常有何异同?

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

6 说出一些常用的类，包,接口，请各举5个

7 说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法(线程安全)，通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

8设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。 public class ThreadTest1{ private int j; public static void main(String args[]){ ThreadTest1 tt=new ThreadTest1(); Inc inc=tt.new Inc(); Dec dec=tt.new Dec(); for(int i=0;i<2;i++){ Thread t=new Thread(inc); t.start(); t=new Thread(dec); t.start(); } } private synchronized void inc(){ j++; System.out.println(Thread.currentThread().getName()+”-inc:“+j); } private synchronized void dec(){ j--; System.out.println(Thread.currentThread().getName()+”-dec:“+j); } class Inc implements Runnable{ public void run(){ for(int i=0;i<100;i++){ inc(); } } } class Dec implements Runnable{ public void run(){ for(int i=0;i<100;i++){ dec(); } } } }

9.JSP的内置对象及方法。

request request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。

response response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法(如cookies,头信息等)

out out 对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。

pageContext pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。

session session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息

application applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息

config config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。

page page表示从该页面产生的一个servlet实例

10.用socket通讯写出客户端和服务器端的通讯，要求客户发送数据后能够回显相同的数据。

参见课程中socket通讯例子。

11说出Servlet的生命周期，并说出Servlet和CGI的区别。

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法(doGet，doPost)等，当服务器决定将实例销毁的时候调用其destroy方法。

与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

12.EJB是基于哪些技术实现的?并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。

SessionBean用于提供对流程的处理，EntityBean提供对数据持久化的管理。StatefulBean有状态，StatelessBean无状态，一般来说StatelessBean速度较快但无法保持客户信息，StatefulBean速度较慢但可以保持客户状态。

13.EJB包括(SessionBean,EntityBean)说出他们的生命周期，及如何管理事务的?

无状态SessionBean的生命周期由容器自由决定。有状态SessionBean在客户需要时被创建，用完后销毁。EntityBean的生命周期也由容器决定，但是在它的不同阶段会根据需要来表示不同的数据内容。

14.说出数据连接池的工作机制是什么?

对表示数据库连接的对象进行包装并预先生成一定数量的连接，当用户请求数据库连接时，从池中选取一个当前不在使用的连接提交给用户。用户使用完成后关闭改连接，此时连接并不真正的被关闭，只是对事物进行提交或回滚等相应的操作，然后回到池中等待被下一次调用。

17你所知道的集合类都有哪些?主要方法? 查API

18给你一个:驱动程序A,数据源名称为B,用户名称为C,密码为D,数据库表为T，请用JDBC检索出表T的所有数据。

[java面试问题及答案]

篇7：java面试问题及答案

第一，谈谈final, finally, finalize的区别。

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

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

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

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

Nested Class (一般是C++的说法)，Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.frontfree.net/articles/services/view.asp?id=704&page=1

注：静态内部类(Inner Class)意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

第四，&和&&的区别。

&是位运算符。&&是布尔逻辑运算符。

第五，HashMap和Hashtable的区别。

都属于Map接口的类，实现了将惟一键映射到特定的值上。

HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

第六，Collection 和 Collections的区别。

Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

Collection是个java.util下的接口，它是各种集合结构的父接口。

第七，什么时候用assert。

断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 Assertionerror。它用于调试目的：

assert(a > 0); // throws an Assertionerror if a <= 0

断言可以有两种形式：

assert Expression1 ;

assert Expression1 : Expression2 ;

Expression1 应该总是产生一个布尔值。

Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。

断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：

javac -source 1.4 Test.java

要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。

要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。

要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八，GC是什么? 为什么要有GC? (基础)。

GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：

System.gc()

Runtime.getRuntime().gc()

第九，String s = new String(”xyz“);创建了几个String Object?

两个对象，一个是”xyx“,一个是指向”xyx“的引用对象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

Math.round(11.5)返回(long)12，Math.round(-11.5)返回(long)-11;

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

第十二，sleep() 和 wait() 有什么区别? 搞线程的最爱

sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非(a)”醒来"的线程具有更高的优先级

(b)正在运行的线程因为其它原因而阻塞。

wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

第十三，Java有没有goto?

Goto—java中的保留字，现在没有在java中使用。

第十四，数组有没有length()这个方法? String有没有length()这个方法?

篇8：40个Java面试问题和答案

40个Java集合面试问题和答案

1.Java集合框架是什么?说出一些集合框架的优点?

每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。

随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。

集合框架的部分优点如下：

(1)使用核心集合类降低开发成本，而非实现我们自己的集合类。

(2)随着使用经过严格测试的集合框架类，代码质量会得到提高。

(3)通过使用JDK附带的集合类，可以降低代码维护成本。

(4)复用性和可操作性。

2.集合框架中的泛型有什么优点?

Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。

泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。

3.Java集合框架的基础接口有哪些?

Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。

Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。

List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。

Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。

一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。

4.为何Collection不从Cloneable和Serializable接口继承?

Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。

例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。

当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。

在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。

5.为何Map接口不继承Collection接口?

尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。

如果Map继承Collection接口，那么元素去哪儿?Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。

6.Iterator是什么?

Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。

7.Enumeration和Iterator接口的区别?

Enumeration的速度是Iterator的两倍，也使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。

迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。为了使它的功能更加清晰，迭代器方法名已经经过改善。

8.为何没有像Iterator.add()这样的方法，向集合中添加元素?

语义不明，已知的是，Iterator的协议不能确保迭代的次序。然而要注意，ListIterator没有提供一个add操作，它要确保迭代的顺序。

9.为何迭代器没有一个方法可以直接获取下一个元素，而不需要移动游标?

它可以在当前Iterator的顶层实现，但是它用得很少，如果将它加到接口中，每个继承都要去实现它，这没有意义。

10.Iterater和ListIterator之间有什么区别?

(1)我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。

(2)Iterator只可以向前遍历，而LIstIterator可以双向遍历。

(3)ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

**********

11.遍历一个List有哪些不同的方式?

List strList = new ArrayList();

//使用for-each循环

for(String obj : strList){

System.out.println(obj);

}

//using iterator

Iterator it = strList.iterator();

while(it.hasNext()){

String obj = it.next();

System.out.println(obj);

}

使用迭代器更加线程安全，因为它可以确保，在当前遍历的集合元素被更改的时候，它会抛出ConcurrentModificationException，

12.通过迭代器fail-fast属性，你明白了什么?

每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动，它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的(ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外)。

13.fail-fast与fail-safe有什么区别?

Iterator的fail-fast属性与当前的集合共同起作用，因此它不会受到集合中任何改动的影响。

Java.util包中的所有集合类都被设计为fail-fast的，而java.util.concurrent中的集合类都为fail-safe的。Fail-fast迭代器抛出ConcurrentModificationException，而fail-safe迭代器从不抛出ConcurrentModificationException。

14.在迭代一个集合的时候，如何避免ConcurrentModificationException?

在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。

15.为何Iterator接口没有具体的实现?

Iterator接口定义了遍历集合的`方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。

这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的。

16.UnsupportedOperationException是什么?

UnsupportedOperationException是用于表明操作不支持的异常。在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在所有add和remove操作中抛出这个异常。

17.在Java中，HashMap是如何工作的?

HashMap在Map.Entry静态内部类实现中存储key-value对。

HashMap使用哈希算法，在put和get方法中，它使用hashCode()和equals()方法。当我们通过传递key-value对调用put方法的时候，HashMap使用Key hashCode()和哈希算法来找出存储key-value对的索引。

Entry存储在LinkedList中，所以如果存在entry，它使用equals()方法来检查传递的key是否已经存在，如果存在，它会覆盖value，如果不存在，它会创建一个新的entry然后保存。

当我们通过传递key调用get方法时，它再次使用hashCode()来找到数组中的索引，然后使用equals()方法找出正确的Entry，然后返回它的值。下面的图片解释了详细内容。

其它关于HashMap比较重要的问题是容量、负荷系数和阀值调整。HashMap默认的初始容量是32，负荷系数是0.75。

阀值是为负荷系数乘以容量，无论何时我们尝试添加一个entry，如果map的大小比阀值大的时候，HashMap会对map的内容进行重新哈希，且使用更大的容量。容量总是2的幂，所以如果你知道你需要存储大量的key-value对，比如缓存从数据库里面拉取的数据，使用正确的容量和负荷系数对HashMap进行初始化是个不错的做法。

18.hashCode()和equals()方法有何重要性?

HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。当我们试着从HashMap中获取值的时候，这些方法也会被用到。如果这些方法没有被正确地实现，在这种情况下，两个不同Key也许会产生相同的hashCode()和equals()输出，HashMap将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。

同样的，所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复，所以正确实现它们非常重要。equals()和hashCode()的实现应该遵循以下规则：

(1)如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。

(2)如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。

篇9：四道微软面试算法题

(1)一个整数数列，元素取值可能是0―65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。

请设计一个算法，当你从该数列中随意选取5个数值，判断这5个数值是否连续相邻。

注意：

-5个数值允许是乱序的。比如：8 7 5 0 6;

-0可以通配任意数值。比如：8 7 5 0 6中的0可以通配成9或者4;

-0可以多次出现;

-复杂度如果是O(n2)则不得分。

(2)设计一个算法，找出二叉树上任意两个结点的最近共同父结点，复杂度如果是O(n2)则不得分。

(3)一棵排序二叉树，令f=(最大值+最小值)/2，设计一个算法，找出距离f值最近、大于f值的结点。复杂度如果是O(n2)则不得分。

(4)一个整数数列，元素取值可能是1~N(N是一个较大的正整数)中的任意一个数，相同数值不会重复出现。设计一个算法，找出数列中符合条件的数对的个数，满足数对中两数的和等于N+1。复杂度最好是O(n)，如果是O(n2)则不得分。

篇10：面试真题及答案

下面是XX年湖南公务员考试真题及答案解析，详情请阅读：

XX年5月13日下午：

1、李源潮的讲话，“艰难困苦玉汝于成”结合村官谈感受

结合大学生村官的实际情况，我认为李源潮同志讲的“艰难困苦玉汝于成”这句话很有思想性、现实性和指导性，对于我们大学生村官坚定信念、扎根基层、做好工作具有很强的指导意义。大学生村官工作在最基层，有的在偏远山区、贫困地区，工作条件艰苦，困难大、挑战多，因此“艰难困苦”是现实情况，同时我们也应该看到，正是在这种最困难的环境中，才能够“玉汝于成”，才能够鼓动我们披荆斩棘、筚路蓝缕的干劲，彰显我们新时期青年干部的精神风貌，成就我们大学生村官的伟大事业。

2、突出人才破格提拔，你怎么看

对此问题，应该辩证地来看待，一方面，对于那些政治坚定、业务精通、作风清廉的突出人才和优秀干部，应该给他们提供足以与他们的能力素质相匹配的舞台，让他们在更高一层的岗位上发挥自己的聪明才智、施展自己的过人本领，使他们想干事、敢干事、能干成事，从而做到才尽其用，更好地建设国家，服务人民，这样有利于促进由中国特色社会主义事业的向前发展，有利于早日实现全面建设小康社会目标。另一方面，人才的选用，应当坚持制度化的原则，人才的破格提拔也应该制度化，做到有章可循、有据可依，不能够仅仅依靠相关领导的主观判断。应当制定一套科学实用的破格提拔制度，使得符合标准的得到破格提拔，不符合标准的即便相关领导再喜欢也不能破格提拔。这样既能够充分利用好人才资源，又杜绝人才破格提拔过程中可能出现的主观性太强甚至任人唯亲现象。

3、贫困县制定耗资巨大历时长的项目，谈感受。

首先，贫困县并非不能搞耗资巨大的项目，只要这个项目是符合当地实际，能够为当地的经济社会发展破除障碍、开辟道路，符合当地人民群众的根本利益，不是政绩工程、面子工程，那么这样的工程都是可以搞的，例如六十年代我们国家搞的原子弹，耗资巨大，而当时人民群众的生活水平还很低，我们勒紧裤腰带还是搞了，因为这项工程是符合实际需要的，原子弹为我们赢得了直到今天的和平发展环境。再如许多贫困县的村村通水泥道路工程，投资也很大，但是能解决贫困县发展的交通瓶颈问题，也是应该搞的。

其次，贫困县搞大工程需要量力而行，尤其应该借力而行，自己搞不起，可以求助于国家和省，还可以借助社会和企业的力量，不能仅仅依靠自身有限的财政力量，不能为了搞大工程就让本地人民群众全部买单，尤其不能增加农民的负担。

总之，我们做工作，应该理论联系实际，一切从实际出发，实事求是地依据我们的需要和条件来采取合适的措施，而不是僵化、片面、教条地想问题和做决策。只要我们坚持一切从实际出发，我们的工作就可以顺利而成功。

XX年5月13日上午：

1.谈谈你的哪些方面比较符合基层？

首先，我出生在农村，对于基层的实际情况比较了解，对于基层的社会有较深的感情，愿意为做好基层、基础工作贡献自己的聪明才智。其次，我不怕吃苦，勇于挑战自我，能够做到在基层平凡的工作岗位上默默无闻、恪尽职守、艰苦奋斗。第三，我受过高等教育，思路开阔，信息渠道较多，掌握较多科学文化知识，可以充分发挥自己的特长为基层工作开创新局面。

2.李鸿忠说的，基层调研要沉下去，不能浮在水面，谈谈你的看法？

李鸿忠同志的话是针对当前有些领导干部下基层调研走马观花、粗枝大叶、流于形式的现象而提出的，可以说李鸿忠同志的话是切中要害、击中靶心。当前领导干部基层调研确实存在浮在表面，不能够沉下去，不能够走进老百姓的家里，走入群众的心中，不能够了解到基层真实情况的现象。要想解决这个问题，就应该按照李鸿忠同志说的要沉下去，走入田间地头，走进厂区车间，走到广大群众中间去，身体力行，和广大群众面对面、心连心、手拉手，这样才能真正了解到真实的社会情况，从而为正确的做决策、定政策打下坚实的基础。

3.政府将景区给企业去经营，企业让景区品味提升了，但门票涨价了，你怎么看？

首先，景区因市场化经营而出现门票涨价的现象，这是正常的市场机制的作用和结果，我们搞社会主义市场经济，应该本着平静的理智的心态来看待涨价现象，涨价是品质提升和成本上升的结果。其次，我们应该看到，旅游业也是一种市场竞争激烈的产业，景区景点之间也存在着争夺客源的竞争，只要这种竞争机制存在，那么就有利于各景区提升品位同时降低收费水平，为消费者提供更加物美价廉的服务。第三，我们应该反对的是那种依靠政府背景，设置壁垒，拒绝其他竞争者参与景区经营投标，搞垄断经营的现象，这种垄断性景区既违背市场经济原则又违反我国的相关法律法规，其结果是景区品质不升反降，消费者权益受到侵害，因此这种现象是我们应该特别加以警惕的。

XX年5月12日下午：

1、知行合一，结合选调生，谈谈你的看法；

作为一名选调生，我认为，知行合一非常重要，尤其对于刚刚毕业即将走上工作岗位的我们来说，做到知行合一，才能够将自己在学校获得的知识和本领运用到现代化建设的实践中去，才能够通过实践检验自己的理论知识，在理论与实践相结合的过程中追求真理、获得真理，探索出一条条能够进一步推进中国特色社会主义事业向前发展的正确道路。

2、管理一方面讲执法，一方面讲人性。你怎么看；

管理包含两个面向，一个是引导、服务、人性的方面，这一方面是管理的主要方面，尤其是政府的管理，主要内容其实就是提供服务和公共产品。另一个是强制、禁止、执法的方面，这一方面是次要的方面，但也是必不可少的，是政府管理的重要一部分，主要内容是规范社会行为，恢复社会秩序。执法的部分其根本目的也还是为人民服务，还是要维护和符合人性的部分。因此，严格执法和讲人性是统一的，两者并不矛盾。那种认为要严格执法就应该践踏人性、对被执法对象实行残酷打击的看法是错误的。这样的严格执法违背了执法工作的初衷和根本目的，不但无助于社会秩序的恢复和重建，还有可能败坏人性，破坏执法机关的公信力，从而使得被执法者获得一种负面的正义感，为自己的违法行为找到依据，从而进一步违法，破坏社会正常秩序。因此，合宜的执法行为一定是人性的执法，只有将执法和人性结合起来，我们的执法工作才能取得更加积极的效果。

3、一社区搞拆迁，为宣传政策，政府用高音喇叭做宣传，半夜还在放，影响群众休息，你怎么看？

一方面，社区的拆迁工作，涉及到社区居民的切身利益，甚至是涉及到老百姓安生立命的根本，是拆迁户十分关注的利益问题，因此做好深入细致的政策宣传工作是十分必要的，只有让大家深入了解拆迁政策，才能避免拆迁过程中不必要的误解和矛盾，是的拆迁工作和谐顺利地开展。另一方面，政策宣传工作也应该注意方式方法，使用半夜放高音喇叭的方式显然是欠妥当的，广播宣传效果有限，很多人只能听到只言片语，难以全面理解，同时高音喇叭在社区中会影响社区居民的生活，即便是在白天使用也是不适宜的，更不要说在晚上，这种半夜使用高音喇叭的做法只能招来居民的反感的抵触情绪，反而不利于拆迁工作的开展。第三，正确的方法是将书面的政策文件连带解读文件逐户发放的居民手中，同时公布政策咨询热线，随时受理居民的询问，以利于拆迁户深入透彻地理解拆迁政策。

XX年5月12日上午：

1、给了郭明义的一段话关于共产党人的奉献精神的话，然后要求你就奉献精神谈谈你如何做好一个选调生？

奉献精神，是共产党人的基本价值最求之一，共产主义的理想的实现，就需要有千千万万的共产党人忘我工作、无私奉献。我们的社会主义事业之所以能有今天的大好局面，也是应为有了许许多多像郭明义这样勇于“拆下肋骨当火把” 点燃自己照亮别人的党员和干部。

对于刚刚走出校园的选调生，我们还很不成熟，对于面临的工作的艰巨性、复杂性还没有透彻的了解，在这种情况下，我们就更需要树立扎根基层、无私奉献的精神，用自己的聪明才智

2、微博，有人说：可爱的是“微”，因为他是一个很好的平台，有人说：可怕的是“博”，因为他成为一个散布谣言的平台。谈谈你的看法。

题目中所述的观点，有一定道理，但是也存在不足之处。微博是一种技术发明，本身是中性的，无所谓好坏，就像以前人们发明的千万种新事物一样。但是这种中性的发明会带来好的坏的两方面影响，汽车的发明便利了人们的出行，但是也带来了车祸，造成生命财产损失，微博也是如此，方便了人与人之间的联系，有利于信息的传播，尤其是造成了一种“自媒体”的状况，使得人们获取信息的渠道摆脱了传统媒体一元化的束缚。但是也有人利用微博传播虚假消息，污染舆论环境。这就需要我们出台类似于交通法规那样的管理措施，来兴利除弊。比如实行网络实名制就是一种杜绝网络谣言的手段。

3、单位领导让你负责考勤，如是便有很多干部电话以各种理由让你代签，对此，你怎么办？

我会这么办：代签一次十块钱，这是零售价。若果全年代签，可以打八折，但是要提前付款。用预收资金雇佣一名失业的大学毕业生，请他替我代签，我可以抽身出来继续干好我的本职工作。这样一举四得：同事解决了签字问题，大学生解决了就业问题，我解决了缺钱的问题，领导解决了面子问题。这样皆大欢喜，一派和谐社会的融融景象呈现在我们面前。啊！

XX年5月11日下午

第一题：罗曼罗兰说最大的敌人就是没有坚定的信念结合自己的经历谈谈

第二题：有些人抱着考选调先考再调最后升的态度。问你怎么看？

第三题：干部要下乡了解群众疾苦，你怎么开展此项工作。

XX年5月11日上午

第一题：你去基层的话，会用怎样的工作方法开展工作？

【参考思路】

1、作为选调生，在到达基层后，我会本着“从群众中来，到群众中去”的原则，怀着一颗为人民服务的心态，做好基层工作。

2、到达基层，我的首要工作，就是要第一时间了解当地的乡情镇况，了解当地选调生的大致工作流程。

3、接下来，通过向领导求真、向同事求帮、向书本求知，我要不断地改善知识结构；在与群众的交流中解决他们的具体困难，抓好重点、统筹规划。

4、最后，我会不断反思和总结自己的工作方式是否符合领导意图，是否符合群众诉求，然后力求改良自己的工作方法，希望能够成为一名不断进步的基层选调生。

第二题：李鸿忠的一句话，年轻工作者要“幼稚”不要“成熟”，你怎么看？