java面试题

应聘Java笔试时可能出现问题
Java基础方面:
1、作用域public,private,protected,以及不写时的区别
Public、Protected、Private是成员访问修饰符；
final、abstract、transient、synchronized、native、strictfp是非访问成员修饰符。
可见性PublicProtectedDefaultPrivate
同一个类是是是是
同一个包中的类是是是否
同一个包中的子类是是是否
同一包外的子类是是否否
同一包外的非子类是否否否

Java的基本包
java.lang 其中包含有：
接口：Comparable、Cloneable、Runable等
类：八个基本数据类型封装类、Math、Runtime、Object、String、StringBuffer、Thread、Exception等

集合框架
集合是将多个元素组成一个单元的对象。集合用于存储、检索和操纵数据。
集合框架提供管理对象集合的接口和类。它包含几个组件，接口是表示集合的抽象数据类型，用于操纵集合；类是用于存储集合的实际数据对象；算法是用于操纵集合的。

2、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

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

就HashMap与HashTable主要从三方面来说.
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap允许在一个集合中有一个null键和在一个集合中有多个null值

Hashtable是HashMap的同步版本；HashMap允许有null值和一个null键，但是，Hashtable不允许有任何内容为null

Hashtable类的对象必须覆盖Object类的hashCode()和equals()方法

关于其他集合类型：
一.ArrayList 提供快速遍历和快速访问。现在设计了新的 RandomAccess 接口，它指出这种列表支持快速随机访问。Vector也实现了RandomAccess 接口。
二.遍历HashSet与HashMap时，其顺序是未知的（但添加删除快）。LinkedHashSet和LinkedHashSet是按照元素的插入的顺序遍历的（遍历快）。
三．TreeSet和TreeMap将保证元素按照元素的自然顺序进行排列。也可以使用一个用户自己实现的比较规则。
四、HashSet有一个散列表支持它。它为基本操作提供固定时间性能。TreeSet它确保了排序集将按元素升序，根据自然顺序排序。

Dictionary类
主要用于将关键字转换成值，该类接收一个关键字并返回一个值。Dictionary是一个抽象类，它是H
Hashtable的超类。
Properties类
扩展了Hashtable类，但Properties对象的关键字和值必须是String类型，并能将对象写入一个输出流并保存在一个文件中，然后可以把它读回一个输入流。


如果需要维护和搜索一个部件列表，它们由唯一的字母数字序列号标示，其中的部件是Part类型，这时应该使用哪种集合？如果我们改变需求，你也需要能够按顺序、按它们的序列号打印出部件？
1、应该选择HashMap
2、应该选择TreeMap

3、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify

GC是什么? 为什么要有GC?
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

7、垃圾回收机制,如何优化程序?
当一个对象失去引用或者离开了作用域后，就成为垃圾而被Java运行环境自动清除，清除垃圾就是清除这些对象。
Java垃圾回收机制的特点是：
1、垃圾回收机制自动运行。系统提供一个低优先级的线程来跟踪内存的分配情况。如果发现某个内存单元不再使用，就清除它。
2、何时清除垃圾是不可预期的。
3、垃圾回收机制随JVM的不同而不同。

Java的垃圾搜索器为内存管理器提供一种自动解决方案。缺点是不能完全控制它什么时候执行以及什么时候不执行。
当垃圾搜集器运行时，其目的是查找和删除不能被访问的对象。
垃圾搜集器受JVM控制，JVM决定什么时候运行垃圾搜集器。从Java程序内可以请求JVM运行垃圾搜集器，但是，在任何情况下都无法保证JVM会答应你的请求。JVM通常会在它感到内存减少时运行垃圾搜集器。
垃圾收集器运行时，当它发现一个对象不能被任何活线程访问时，它将认为该对象符合删除条件，它可能在某时删除该对象。
垃圾收集器不能保证有足够的内存，它只能保证可以使用的内存将尽可能被有效的管理。
使对象符合垃圾搜集器搜索条件的情况有：出现空引用、重新为引用变量赋值、隔离引用。

强制执行垃圾搜集：
Runtime对象为直接与虚拟机通信提供一种机制。System类可以调用与其相同的方法。
请求垃圾收集器的最简单的方法是：System.gc();

Javac编译选项？
G产生调试信息
g:none不产生调试信息
verbose输出编译器消息，可以知道程序编译时用到了哪些Java类
Noware编译时不产生警告信息
encoding指出原文件的编码方式
D指定类文件产生的目录
classPath指出用户class文件的路径
sourcePath指出用户源文件路径

9、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?
答：Collection FrameWork如下：
核心接口有：
CollectionSetSorted Set
ListMapSorted Map

Set接口：不允许重复的元素。它对add、equals、hashCode方法增加了限制
SortedSet接口：扩展了Set接口，此接口的元素按升序排序。
List接口：一些集合具有顺序，即在一个项目后添加另一个项目。列表可以有重复元素。提供了ListIterator，允许向前或向后移动元素。
Map接口：将键映射到值得对象。Map不能包含重复键，但可以包含重复值。每个键最多都只能映射到一个值。

核心设计类：
Map 设计Set 设计List 设计
HashMapHashSetArrayList
HashtableLinkedHashSetVector
TreeMapTreeSetLinkedLisk
LinkedHasMap

散列表是最快的数据存储结构，它是一个数组。数据存储在数组中散列函数指定的特定下标。散列函数是一组输入数据和一组整数之间的映射。

集合类和接口层次

Collections是一个类，带有用于处理集合的静态实用方法
Collection是一个接口，带有多数集合常用的方法声明，包括add、remove、contains、size、iterator

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射

集合框架的优点：
提供一组可用的集合接口，可以方便地扩展或改写集合；
接口和算法的可重用性提高了软件的可重用性；
提供了有效的数据结构和算法，减少了编程工作。

10、Java中异常处理机制，事件机制？
事件代表了组件之间的交互。是一种在源对象和监听对象之间，某种状态发生变化的传递机制。
通过事件处理机制，可以让一些组件作为事件源，发出可被组件环境或其它组件接收的事件。这样，不同的组件就可以组合在一起，组件之间通过事件传递进行通信，构成一个应用。
在java中实现事件机制的事件模型由三个部分构成：一个事件对象用于描述事件源的状态变化；一个事件源将会产生事件，提供注册的事件监听器的方法，把事件发送到监听器；事件监听器接收事件通知，实现该事件的监听器接口。

异常实际上是程序中错误导致中断了正常的指令流的一种事件.
Java异常处理用于在方法中能检查出错误但不能处理错误的情况，在这样的方法中将抛出一个异常。如果一个异常与某个catch程序块中的参数匹配，那么就执行该catch块中的代码。指出try catch finally的工作顺序。

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

事件有哪些？

什么是断言机制？
断言从JDK1.4版开始引入，它让开发期间测试假设，而没有付出为异常编写异常处理程序方面的代价，一旦程序完成开发，并全部部署，假设将从不会发生。
主要作用：因为在开发时对自己的假设非常肯定，所以不想花费时间来编写异常处理代码。断言让在开发期间测试你的假设。
private void method（int num）{
assert(num>=0）;//这里假定参数num是正数，如果不是真的将抛出一个AssertionError错误
useNum(num+x);
}
断言有两种形式：简单和非常简单。
非常简单：
private void doStuff（）{
assert(y>x);
//其他代码
}
简单：
将通过表达式的值向错误跟踪栈中添加更多信息，提供了更多调式帮助信息。
private void doStuff（）{
assert(y>x):”y is ”+y+” x is”+x;
//其他代码
}
运行时启用断言：
java –ea com.geeksanonymous.TestClass

运行时禁用断言：
java –da com.geeksanonymous.TestClass

11、JAVA中的多形与继承？
希望大家补上，谢谢

对象是定义了边界的、与要解决的问题有关的概念或事物。它们用于帮助理解现实世界。
类是拥有相同特性、共同的行为和共同的关系的一组对象。
封装是让开发者有选择地隐藏类中的特性和方法的过程
继承是允许通过重用现有类来构建新类的特性。]
多态性使用同一函数在不同的类上具有不同的行为。Java中的多态性是通过方法的动态绑定实现的。

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

abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 都不能

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

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
可以继承其他类或完成其他接口，在swing编程中常用此方式。

IO流
字节流：数据在存储时与传输时都是以字节为单位进行的。通常用于读写二进制数据，如图像和声音文件。
字符流：数据在存储与传输时都是以字符为单位进行的。

流：对数据源的一种抽象，其目的是想用统一的方式访问各种不同的数据源（文件、网络、内存的缓冲区）

文件读写的基本类：File类提供定位本地文件系统，描述文件和目录的功能。

管道流用于在线程之间通信：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter
线程1àPipedOutputStreamàPipedInputStreamà线程2

键盘输入：
try{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s=br.readLine();
System.out.println(s);
}catch(Exception e){
}

文件输入输出：
try{
File f=new File("test.txt");
FileOutputStream fout=new FileOutputStream(f);
fout.write(System.in.read());
fout.close();
FileInputStream fin=new FileInputStream(f);
int size=fin.available();
for(int i=0;i<size;i++){
System.out.print((char)fin.read());
}
fin.close();
}catch(Exception e){
}

通过网络传输文件：
客户端：
File f=new File("bk.exe");
FileInputStream fin=new FileInputStream(f);
Socket st=new Socket("localhost",6000);
BufferedOutputStream bout=new BufferedOutputStream(st.getOutputStream());
int size=fin.available();
for(int i=0;i<size;i++){
bout.write(fin.read());
}
服务器端：
ServerSocket server=new ServerSocket(6000);
Socket st=server.accept();
File f=new File("kk.exe");
BufferedInputStream bin=new BufferedInputStream(st.getInputStream());
FileOutputStream fout=new FileOutputStream(f);
int i=0;
while(i!=-1){
i=bin.read();
fout.write(i);
}

串行化的注意事项以及如何实现串行化
对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力，叫做对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization)。
序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一线程中或通过网络连接将对象数据发送到另一主机。
一：对象序列化可以实现分布式对象。
二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。
// 序列化 today's date 到一个文件中.
   FileOutputStream f = new FileOutputStream("tmp");
   ObjectOutputStream s = new ObjectOutputStream(f);
   s.writeObject("Today");
   s.writeObject(new Date());
   s.flush();
//从文件中反序列化 string 对象和 date 对象
   FileInputStream in = new FileInputStream("tmp");
   ObjectInputStream s = new ObjectInputStream(in);
   String today = (String)s.readObject();
   Date date = (Date)s.readObject();
记住，对象流不序列化static或transient。
序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。
如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流

NIO的特征
l旧的I/O是以字节为单位进行读写的，而新的I/O是以块为单位进行读写的
l以新的Channel抽象类来配合节点类
l使用Buffer的概念来进行基本数据类型的存取
l增加更多字节编码的支持
l内存映像及数据锁定的支持
l提供非阻塞的存取机制
l提供正则表达式式的验证机制


import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.channels.spi.*;
import java.net.*;
import java.util.*;

class NBTest {
NBTest(){}
public void startServer() throws Exception{
int channels = 0;
int nKeys = 0;
int currentSelector = 0;
Selector selector = Selector.open();

//建立Channel 并绑定到9000端口
ServerSocketChannel ssc = ServerSocketChannel.open();
InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(),9000);
ssc.socket().bind(address);

//使设定non-blocking的方式。
ssc.configureBlocking(false);

//向Selector注册Channel及我们有兴趣的事件
SelectionKey s = ssc.register(selector, SelectionKey.OP_ACCEPT);
printKeyInfo(s);

while(true) //不断的轮询
{
debug("NBTest: Starting select");
//Selector通过select方法通知我们我们感兴趣的事件发生了。
nKeys = selector.select();
//如果有我们注册的事情发生了，它的传回值就会大于0
if(nKeys > 0){
debug("NBTest: Number of keys after select operation: " +nKeys);
//Selector传回一组SelectionKeys
//我们从这些key中的channel()方法中取得我们刚刚注册的channel。
Set selectedKeys = selector.selectedKeys();
Iterator i = selectedKeys.iterator();
while(i.hasNext()){
s = (SelectionKey) i.next();
printKeyInfo(s);
debug("NBTest: Nr Keys in selector: " +selector.keys().size());

//一个key被处理完成后，就都被从就绪关键字（ready keys）列表中除去
i.remove();
if(s.isAcceptable()){
// 从channel()中取得我们刚刚注册的channel。
Socket socket = ((ServerSocketChannel)s.channel()).accept().socket();
SocketChannel sc = socket.getChannel();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ |SelectionKey.OP_WRITE);
System.out.println(++channels);
}else{
debug("NBTest: Channel not acceptable");
}
}
}else{
debug("NBTest: Select finished without any keys.");
}
}
}

private static void debug(String s){
System.out.println(s);
}

private static void printKeyInfo(SelectionKey sk)
{
String s = new String();
s = "Att: " + (sk.attachment() == null ? "no" : "yes");
s += ", Read: " + sk.isReadable();
s += ", Acpt: " + sk.isAcceptable();
s += ", Cnct: " + sk.isConnectable();
s += ", Wrt: " + sk.isWritable();
s += ", Valid: " + sk.isValid();
s += ", Ops: " + sk.interestOps();
debug(s);
}

public static void main (String args[])
{
NBTest nbTest = new NBTest();
try{
nbTest.startServer();
}catch(Exception e){
e.printStackTrace();
}
}
}

Socket通信(TCP、UDP区别及Java实现方式)
套接字是一种进程间的数据交换机制。客户端和服务器通过套接字建立连接和进行通信。套接字是由IP地址、传输协议和一个端口号三部分组成的。
TCP/IP协议：其中TCP 为传输控制协议是传输层协议，
功能TCPUDP
数据传输连续的有序数据流消息传输
多路功能接收主机根据端口号决定数据流向那个应用相同
可靠传输使用TCP头部的序列与确认字段进行数据确认无
流量控制使用窗口机制的流量控制无
连接使用3次握手建立连接；连接后一直保持连接直到终止连接无连接

URL的组件：协议、IP地址或主机名、端口号和实际文件路径

import java.net.*;
import java.io.*;

public class DatagramServer{
public static DatagramSocket ds;
public static int clientport=1089,serverport=1090;
public static void main(String args[]) throws Exception{
byte buffer[]=new byte[1024];
ds=new DatagramSocket(serverport);
BufferedReader dis=new BufferedReader(new InputStreamReader(System.in));
System.out.println("服务器正等待输入");
InetAddress ia=InetAddress.getByName("localhost");
while(true){
String str=dis.readLine();
if(str==null||str.equals("end")){
break;
}
buffer=str.getBytes();
ds.send(new DatagramPacket(buffer,str.length(),ia,clientport));
}
}
}

import java.net.*;
import java.io.*;

public class DatagramClient{
public static DatagramSocket ds;
public static byte buffer[]=new byte[1024];
public static int clientport=1089,serverport=1090;
public static void main(String args[]) throws Exception{
ds=new DatagramSocket(clientport);
System.out.println("客户端正在等待服务器发送数据");
while(true){
DatagramPacket p=new DatagramPacket(buffer,buffer.length);
ds.receive(p);
String psx=new String(p.getData(),0,p.getLength());
System.out.println(psx);
}
}
}

13、Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？
答:Server端程序:
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();
}
};

Client端程序:
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();
}
};

常见排序法：
public class Sort{
public static int count=0;
public boolean LT(int num1,int num2){
return num1<num2;
}
public void output(int[] array){
System.out.print("第"+count+"次排序：");
for(int i=0;i<array.length;i++)
System.out.print(array[i]+"    ");
System.out.println();
}

//冒泡排序法
public void BubbleSort(int[] array){
boolean swap=true;
int index=0;

int i=0;
while(i<array.length-1){
int temp=array[i];
for(int j=i;j<array.length;j++){
if(!LT(array[i],array[j])){
int temp2=array[i];
array[i]=array[j];
array[j]=temp2;
swap=true;
index=j;
}else{
swap=false;
}
}
i++;
if(swap){
array[i]=array[index];
array[index]=temp;
i++;
}
output(array);
}
}

//直接插入排序法
public void InsertSort(int[] array){
for(int i=1;i<array.length;++i){
if (LT(array[i],array[i-1])){
int temp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
for(int j=i-1;j>0;--j){
if(LT(array[j],array[j-1])){
array[j]=array[j-1];
array[j-1]=temp;
}else{
break;
}
}
output(array);
}
}
}

//快速排序法
private int Partition(int array[],int low,int high){
int temp=array[low];
int pivotkey=array[low];
while(low<high){
while(low<high&&array[high]>pivotkey)--high;
array[low]=array[high];
while(low<high&&array[low]<=pivotkey)++low;
array[high]=array[low];
}
array[low]=temp;
output(array);
return low;
}

public void QSort(int array[],int low,int high){
if(low<high){
int pivotloc=Partition(array,low,high);
QSort(array,low,pivotloc-1);
QSort(array,pivotloc+1,high);
}
}

void QuickSort(int array[]){
QSort(array,0,array.length-1);
}
public static void main(String args[]){
int array[]={49,38,65,97,76,13,27,49};
Sort sort=new Sort();

System.out.println("===================================");
sort.output(array);
System.out.println("优化冒泡排序法");
sort.BubbleSort(array);

System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("直接插入排序法");
sort.InsertSort(array);

System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("快速排序法");
sort.QuickSort(array);
}
}

14、如在COLLECTION框架中，实现比较要实现什么样的接口？
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

什么是线程？
线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程（light-weight process）。一个进程中可以包含多个线程。

　　一个线程是一个程序内部的顺序控制流。
　　1. 进程：每个进程都有独立的代码和数据空间（进程上下文） ，进程切换的开销大。
　　2. 线程：轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
　　3. 多进程：在操作系统中，能同时运行多个任务程序。