面试难点总结[java篇]

最新推荐文章于 2024-04-20 15:27:58 发布

菜鸟-北京

最新推荐文章于 2024-04-20 15:27:58 发布

阅读量746

点赞数

分类专栏：面试相关

面试相关专栏收录该内容

9 篇文章 0 订阅

订阅专栏

http://blog.csdn.net/qiyuexuelang/article/details/8823225

填空选择类

1.八大基本数据类型的范围及默认值

数据类型大小范围默认值

byte(字节) 8 -128 - 127 0

shot(短整型) 16 -32768 - 32768 0

int(整型) 32 -2147483648-2147483648 0

long(长整型) 64 -9233372036854477808-9233372036854477808 0

float(浮点型) 32 -3.40292347E+38-3.40292347E+38 0.0f

double(双精度) 64 -1.79769313486231570E+308-1.79769313486231570E+308 0.0d

char(字符型) 16 ‘ \u0000 - u\ffff ’ ‘\u0000 ’

boolean(布尔型) 1 true/false false

注意：string不是基本数据类型

2.Integer是java提供的封装类 int是原始类型； Integer的缺省值 null int的缺省值 0

3.string类提供了数值不变的字符串，如果操作少量数据用string

而stringBuffer类提供的字符串可修改（动态），多线程操作字符串缓冲区下操作大量数据

4.ArrayList、Vector使用数组存储数据，索引快插入慢

Vector同步线程安全，ArrayList不是线程安全;

Vector在需要增长时默认增长方式为原来的一倍，而ArrayList为原来的一半

LinkedList使用双向链表存储，索引难插入快

5.sleep（）线程类方法，导致此线程暂停执行时间，但监控状态依然保持，到时自动恢复占用CPU

wait（）Object类方法，对对此对象调用wait（）方法导致线程放弃对象锁，只有对此对象发出 notify()方法后，本线程才进入对象锁对其进行执行。

6.java中以unicode编码，一个char占16个字节，故能放一个中文

7.java常见的类型流：字节流Input/OutputStream 字符流Reader Writer

8.常见的runtime exception：ArrayStoreException BufferOverflowException ClassNotFoundException NumberFormatException IndexOutOfBoundsException

NullPointerException NoSuchElementException

9.java常用包：java.io.*;java.util.*;java.long.*;java.net.*;java.sql.*;javax.servlet;

java常用类：BufferedReader BufferedWriter FileReader String Integer java.util.Date

system Class List HashMap

java常用接口：Romote List Map Document Modelist Servlet HttpServletRequest HttpServletResponse session

10.switch 作用类型char byte int short

11.Class类是由java编译器自动产生，它伴随着每个类

任何一个java程序都默认引入一个包，这个包叫java.long

java语言中，所有类或接口的父类 java.long.Object

12.java实现序列化的方法是实现java.io.Serializable

13.Collection框架实现比较要实现 Comparable接口和Comparator接口

14.在try-catch-finally语句中，System.exit()是干掉finally的最佳办法

判断改正类

1.short s1 =1;s1=s1+1 (需强转) short s1 =1;s1+=1; 正确

2.接口可以继承接口抽象类可以实现implements接口

3.数组有length属性，String有length方法 String类是final类，故不可继承

4.set里元素通过iterator（）方法区分重复与否，因此equals（）判断两个set是否相等

5.构造器不能被继承，因此不能重写，但可被下载

6.不能从static方法内发出对非static方法的调用

7.try内有return，紧跟后的finally依然会执行，在return之前

8.float f =(float)3.4

9.boolean b = null 错误！ boolean只能为true或false

10.是否合法

2variable 错 variable2 对 _whatavariable 对 _3_ 对 $anothervar 对

#myvar 错

11.break case 语句没有break 就会继续下面的语句，满足case后的case失效，执行后面的代码直至遇到break为止

12.C语言 int i = 0;if(i){} true

java语言 return false

13.class Base{

class Sub extends Base{}

public class Cex{

//主方法（简）

main{

Base b = new Base ();

Sub s = (Sub)b;

}

运行结果：Runtime Exception

}

14.java没有 <<<</div>

System.out.println(-1>>>2); 输出一个大于10的结果（1073741823）

------------------(-1>>2）; 输出一个-1

------------------(2>>1); 输出1

15.var a = 2;var b = 3; (二进制解决) a&b =2, a|b =3, a^b=1 , ~a =-3

16.组件必须放到一定的容器中才能显示

17.final的变量只能在两个地方赋值，一个是定义它的时候，一个是在构造函数中

static final声明的变量一律常量，必须声明时初始化

18.class SomeThing{

int i;

public void doSomething(){

System.out.println("i+"+i);

}

正确

19.数据类型转换(低向高要强转，高向低不需要)

long l =4990; true int i = 4L; false double d = 34.4; true double t = 0.9F; true

20.StringBuffer sb = "ab" ; false 需初始化

21.boolean b = new Boolean("abce") true 返回值为false

22.程序段 1）fobj = new Object(); 2)fobj.Method(); 3)fobj = new Object();4)fobj.Method();

符合垃圾收集器的代码是 3

符合条件：1.给对象赋了空值 2.给对象赋了新值

1）Object sobj = new Object();2)Object sobj = null;

3)Object sobj = new Object(); 4)sobj = new Object();

符合垃圾收集器的代码是 1,3

23.-0.0==+0.0 但+0.0>-0.0在比较max min时

24.

比较问答类

1.线程同步的方法：

wait（）使线程处于等待，释放对象锁 sleep（）使当前线程睡眠

notifyAll（）唤醒所有等待线程 notify（）唤醒处于等待的某个线程

2.多线程实现方法：

继承Thread类和实现runable接口

同步实现方法：

synchronized，wait，notify

3.throw 明确地抛出一个“异常” throws表明一个成员函数可能要抛出的“异常”

4.java实现多态的机制：

方法重写Overriding 父类与子类之间多态性的一种表现

方法重载OverLoading 一个类中多态性的表现

5.静态变量与实例变量：静态变量是常量，实例变量是变量 class A a; a.i = 10;

6.软件开发中的设计模式：

单例模式主要作用是保证在java应用程序中，一个类class只有一个实现类

DAO模式模板模式工厂模式委托代理模式 MVC模式

6.抽象类和接口

1）定义

抽象类：声明方法的存在却不去实现他的类，用于创建一个体现某些行为的类，但不能在该类中实现该类的情况的

接口:抽象类的特例，接口中所有方法都必须是抽象的，接口定义的方法默认为public

是没有实现的方法和常量组成的集合，用来解决java不支持多继承问题

2）不同

抽：一个类只能继承一个抽象类，若干个继承类继承一个抽象类

口：一个雷可以实现多个接口。若一个类实现一个接口，那么必须实现接口的全部方法

抽：成员变量可以是任意类型

口：public static final

抽：成员方法可以有abstract的，也可以不是

口：方法都是public，且都没实现

3）共性

都不能被实例化，但都可以定义一个抽象类/接口的对象变量（引用）指向继承/实现它的子类对象

抽象类中可以由抽象方法，也可没有，有抽象方法的类一定是抽象类

7.在编程过程中哪些地方该用注解：

8.&和&&

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）

9.数据连接池与数据库连接池

10.heap和stack的区别

栈是一种线性集合，其删除和添加元素的操作应该在同一时间完成。按先进后出的方式处理

堆是栈的一个组成

11.CORBA是什么?用途是什么?

答：CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture)，由对象管理组

   织 (Object Management Group，缩写为 OMG)标准化。它的组成是接口定义语言(IDL), 语言绑定       (binding:

    也译为联编)和允许应用程序间互操作的协议。其目的为：

    用不同的程序设计语言书写

    在不同的进程中运行

    为不同的操作系统开发

  12. 谈谈final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。finally是异常处理语句结构的一部分，表示总是执行。finalize是 Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

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

　可以继承其他类或完成其他接口，在swing编程中常用此方式。

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

　 Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

代码编写类

1.2*8 最快的代码 2<<3移位

2.字符转换

[java] view plain copy

public String translate (String str){
String tempStr = "";
try{
tempStr = new String(str.getBytes("ISO-8859-1"),"GBK");
tempStr = tempStr.trim();
}catch(Exceptione){
out.print(e.getMessage());
}
return tempStr;
}

3.插入排序

[java] view plain copy

public class CharuSort {
public static void main(String[] args){
int[] sort={4,6,3,9,5};
Sort(sort);
for(int i=0;i<sort.length;i++)
System.out.print(sort[i]+" ");
}
public static void Sort(int[] sort){
int i; //为扫描次数
int j; //定为比较得元素
for(i=1;i<sort.length;i++){ //扫描次数为sort.length-1
int temp; //temp用来暂存数据
temp=sort[i];
j=i-1;
while(j>=0&&temp<sort[j]){ //如果第二个元素小于第一个元素
sort[j+1]=sort[j]; //把所有的元素往后推一个位置
j--;
}
sort[j+1]=temp; //最小的元素放到第一个位置
}
}
}

4.java冒泡排序

[java] view plain copy

public class BubbleSort {
private static int c =0;//执行次数
public static void main(String[] args) {
int[] a = {60,1 , 35 ,32, 44 , 321 };
sort(a);
System.out.println(c);
for(int i:a){
System.out.print(i+" ");
}
}
public static void sort(int[] array) {
int length = array.length;
int temp;
boolean isSort;
for(int i = 1; i < length; i++) {
c++;
isSort = false;
for(int j = 0; j < length - i; j++) {
if(array[j] > array[j+1]) {
//交换
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
isSort = true;
}
}
if(!isSort) break; //如果没有发生交换，则退出循环
}
}
}

5.简单的C/S程序。java通信编程，用JavaSocket编程读写字符

服务器端：

[java] view plain copy

package test;
import java.net.*;
import java.io.*;
public class Server
{
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server()
{
try
{
ss=new ServerSocket(10000);
while(true)
{
socket = ss.accept();
String RemoteIP = socket.getInetAddress().getHostAddress();
String RemotePort = ":"+socket.getLocalPort();
System.out.println("A client come in!IP:"+RemoteIP+RemotePort);
in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println("Cleint send is :" + line);
out = new PrintWriter(socket.getOutputStream(),true);
out.println("Your Message Received!");
out.close();
in.close();
socket.close();
}
}catch (IOException e)
{
out.println("wrong");
}
}
public static void main(String[] args)
{
new Server();
}
};

客户端：

[java] view plain copy

package test;
import java.io.*;
import java.net.*;
public class Client
{
Socket socket;
BufferedReader in;
PrintWriter out;
public Client()
{
try
{
System.out.println("Try to Connect to 127.0.0.1:10000");
socket = new Socket("127.0.0.1",10000);
System.out.println("The Server Connected!");
System.out.println("Please enter some Character:");
BufferedReader line = new BufferedReader(new
InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(),true);
out.println(line.readLine());
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
socket.close();
}catch(IOException e)
{
out.println("Wrong");
}
}
public static void main(String[] args)
{
new Client();
}
};

6.随机产生0.0-0.1的双精度随机数

[java] view plain copy

Double i = Math.random();
int b = (int)(Math.random()*1000); //0-1000的整随机数
int c = (int)(Math.random()*(max-min)+min); //产生于两整数间的随机数

7.单例模式

[java] view plain copy

public class Singleton {
　　private Singleton(){}
　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用
　　private static Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}

8.简单的JDBC连接

9.折半查找（递归）

[java] view plain copy

package test;
public class Search2 {
public static void main(String[] args) {
int [] a = new int[]{12,34,44,54,120,131};
int result = searchByTwo(a,0,a.length-1,120);
if(result ==-1){
System.out.println("未找到");}
else{
System.out.println("该数据所在位置"+(result+1));
}
}
public static int searchByTwo(int[] array ,int l0,int hi,int x){
//当a[i] = x,并且i>=0时，返回i，否则返回-1
if(l0 > hi){
return -1;
}
int i = (l0+hi)/2;
if(array[i]==x){
return i;
}else if(array[i]<x){
return searchByTwo(array,i+1,hi,x);
}else{
return searchByTwo(array,l0,i-1,x);
}
}
}

10.汉诺塔（递归）

[java] view plain copy

public class Hanoi {
public static void main(String[] args) {
//汉诺塔
/*
三步走战略：
1.将柱x上较小的n-1个盘移到柱Z
2.将柱x上的剩余盘移到柱y
3.将柱z上的n-1个盘移到柱y
*/
runHanoi(4, 'A', 'B', 'C');
}
public static void runHanoi(int n,char x,char y,char z){
if(n==1){
System.out.println("move top disk from peg " + x+" to peg "+z);
}else {
runHanoi(n-1,x,z,y);
runHanoi(1,x,y,z);
runHanoi(n-1,y,x,z);
}
}
}

11.不使用Synchronized关键字保证foo（）线程的安全

12.如果系统要使用超大整数（超过long长度）设计一个数据结构来存储这种超大型整数及设计一种算法实现超大整数的加法运算

[java] view plain copy

package test;
public class LongAdd {
public static String doAdd(String str1,String str2){
String str ="";//相加后的字符串
String strTmp = ""; //补零对齐
int jw = 0; //进位
int temp; //每一位相加的结果
int len1 = str1.length();
int len2 = str2.length();
int maxLength = (len1>len2)?len1:len2;
int minLength = (len1<len2)?len1:len2;
for(int i =maxLength-minLength;i>0;i++){
strTmp += "0";
}
if(maxLength == len1){
str2 = strTmp +str2;
}else{
str1 = strTmp +str1;
}
for(int i =maxLength-1;i>=0;i--){
int temp1 = Integer.parseInt(String.valueOf(str1.charAt(i)));
int temp2 = Integer.parseInt(String.valueOf(str2.charAt(i)));
if(temp1+temp2+jw>=10&&i!=0){
temp = temp1+temp2+jw-10;
jw = 1;
}else{
temp = temp1+temp2+jw;
jw = 0;
}
str = String.valueOf(temp)+str;
}
return str;
}
public static void main(String[] args) {
String str1 = "1234567890123456789";
System.out.println("str1:\n"+str1);
System.out.println("result:\n"+doAdd(str1,str1));
}
}

13 设计四个线程

[java] view plain copy

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

14.编写File程序，实现以下功能

1.计算文件/文件夹的大小（M）

2.判断操作对象为文件OR文件夹，如果是文件，输出文件内容

否则列出该文件夹下所有目录

[java] view plain copy

public static void main(String[] args) throws Exception
{
getFile(new File("C:\\entityBean"),"\t");
}
public static void getFile(File f,String sem) throws Exception
{
System.out.println(sem+f.getName());
File fl[]=f.listFiles();
if(fl.length>=1)
{
for(int i=0;i<fl.length;i++)
{
if(fl[i].isDirectory())
{
getFile(fl[i],sem+"\t");
}
}
}
}

15.编写一个算法，实现一个字符串所有字符的全排列，并记录排列总数

[java] view plain copy

package test.hello;
public class AllCombString {
public static int t;//组合个数
public static void main(String[] args) {
String str = "abcdefg";
char[] c = str.toCharArray();
t++;
allCombString(c,0);
System.out.println(t);
}
public static void allCombString(char[] c,int s){
int l = c.length;
if(l-s==2){
char temp = c[l-1];
c[l-1] = c[l-2];
c[l-2] = temp;
println(c);
t++;
}
else{
for(int i=s;i<l;i++){
moveToHead(c,i,s);
char ct[] = new char[l];
System.arraycopy(c, 0, ct, 0, l);//保持其他元素位置不变
allCombString(ct,s+1);
}
}
}
public static void moveToHead(char[] c,int id,int s){
if(id>s&&id<c.length){
char temp = c[id];
for(int i=id;i>s;i--){
c[i] = c[i-1];
}
c[s] = temp;
println(c);
t++;
}
}
public static void println(char[] c){
System.out.println(new String(c));
}
}

16.请在下面程序相应位置填充合适代码，实现提示功能

public class RightDemo {
public static void main(String[] args) {
int i = 0;
{
//添加一段代码使得控制台输出right

}
if (i + 1 < i) {
System.out.println("right");
} else {
System.out.println("wrong");
}
}
}

[java] view plain copy