java 笔试题收集

1、集合框架

集合框架分为三个部分。第一部分Collection接口，第二部分是Map接口，第三部分是Collections类，用来帮助我们操作集合的类(都是静态的方法)。

第一部分 Collection 接口下有两个子接口List、Set.

List接口下常用的类有ArrayList、LinkedList、Vector.

ArrayList和Vector的底层都是用一个Object[]实现的，所以用他们来定位索引比较高效。

LinkedList底层是用双向链表来实现的，所以添加或删除元素比较高效。

Vector是他们中间惟一一个线程安全的，（也就是说支持同步操作）。

综上List接口都是有序和可重复的

    set接口常用的类有HashSet、TreeSet、LinkedHashSet(不常用)

存入Set 的每个元素必须唯一，不保证维护元素的次序.加入Set 的Object必须定义equals()方法 
－－HashSet　为快速查找而设计的Set ，存入HashSet对象必须定义hashCode(). 
－－TreeSet  保护次序的Set ，使用它可以从Set 中提取有序序列. 
－－LinkedHashSet　　具有HashSet的查询速度，且内部使用链表维护元素的次序. 
它们之间的存储方式不一样： 
TreeSet采用红黑树的树据结构排序元素. 
HashSet采用散列函数，这是专门为快速查询而设计的. 
LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序. 

使用HashSet/TreeSet时，必须为类定义equals()；而HashCode()是针对HashSet，作为一种编程风格，当覆盖equals()的时候，就应该同时覆盖hashCode().

第二部分Map都是存放键值对（键不能重复）

HashMap：它是根据键的HashCode值存储数据的，可以根据键值获取value值，具有很快的访问速度；

遍历时获取数据的顺序完全是随机的；最多只有一条记录的键值为null；不是线程安全的，即任一时刻，

可以有多个线程同时写HashMap，可能到时数据的不一致，如果需要同步，可以用

Collections的synchronizedMap方法使HashMap具有同步的功能，或者使用ConcurrentHashMap；

HashTable：与hashMap类似，不同的是，支持线程同步，不允许键值或值为空，在写入时速度较HashMap慢；

LinkedHashMap：与hashMap类似，记录了数据的插入顺序，用Iterative遍历时，先得到的数据肯定是先插入的，遍历时速度较HashMap慢；

TreeMap：实现的是SortMap接口，能够把它保存的记录根据键排序，默认的是按键值的升序排序；可以自己设置。

故：HashMap里面存入的键值对在取出的时候是随机的,它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。
LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同，那么用LinkedHashMap可以实现。

2、多线程的两种表示形式

继承Thread类

public Class A extends Thread{

public void run(){

}

}

A thread1=new A();

thread1.start();

实现Runnabl接口的类（创建Thread类对象时，把实现了该接口的对象传进去）

pubic void Claa B implements Runnable{

public void run(){

}

}

B runnable1=new B() 

Thread thread2=new Thread(runnable1)

用匿名内部类可以写成

Thread thread2=new Thread(new Runnable(){

public void run(){

}

});

public class Outer

{

            publicvoid start()

            {

                     newThread(

new Runable(){

                                        publicvoid run(){};

}

).start();

           }

}.

在线程中wait与sleep区别

1：wait是 object定义的方法，而sleep是线程Thread定义的方法

2：sleep是让当前的线程睡泯，所以可放在任何位置。而 wait是让当前的线程放弃资源的使用权，必须放在

在同步块或同步方法里面。

3：sleep他不会释放对象锁，而wait会释放对象的同步锁

4：sleep是等待一段时间后自动醒来，而wait 必须让其它的程唤醒。

线程同步：先争锁，再争cpu.

争锁发生在锁池中，争cpu：在就绪状态下。有锁的才能争cpu。

synchronized修鉓方法时只能锁this，而修饰代码块时可锁任何对象。

线程拥有的几种状态

就绪状态：线程分配了cpu以外的全部资源，等待获得 cpu调度。

执行：线程获得cpu,，正在执行。

阻塞： 线程由于发生IO或者其他的操作导致无法继续执行，就放弃处理机，转入线程就绪队列

挂起：由于终端请求，操作系统要求等原因，导致挂起

3、创建对象的四种方式

new 、反射、clone、反序列化。

4、创建数组的几种方式

1、int[] a ={1,2,3};

String[] str={new String("1",new String("2")};

2、int[] a=new int[2];

a[0]=0;a[1]=1;

5、.==和equals()区别

其实他们本来都是比地址的，只是String类对Object类下的equals()方法进行了重写让他进行的是内容的比较。

6、GUI响应一个事件的代码如何写

确定事件源（产生事件对像 ）

确定事件监听器（监听是否产生事件对象）

监听器需要实现事件监听接口，重写其中的方法。在事件源和事件监听器对象中进行约定的接口类,被成为事件监听器接口. 

完成监听器在事件源上的注册

1. JDK中也提供了大多数事件监听器接口的最简单的实现类,称之为事件适配器(Adapter)类. 
2. 用事件适配器来处理事件,可以简化事件监听器编写 

Frame f= new  Frame( "UGI应用程序 ! " ); //创建一个窗口实例,标题为UGI应用程序   

 //f.addWindowListener(new MyWindowListener());//注册事件监听器  

f.addWindowListener(new MyWindowAdapter());//注册事件适配器

 public class MyWindowListener implements WindowListener{

1. public void windowClosing(WindowEvent e) {  
2.         // TODO Auto-generated method stub  
3.          e.getWindow().setVisible(false);//隐藏窗口  
4.         ((Window)e.getComponent()).dispose();//关闭窗口  
5.         //另一种方式:  
6.         //((Window)e.getSource()).dispose();  
7.          System.out.println("已经关闭窗口 ! ");  
8.         System.exit(0);//关闭程序  
9.     }  
10. /*
11. 其它的方法就要空实现了
12. */
13.   public void windowActivated(WindowEvent e){}；
    
14.   public void windowClosed(WindowEvent e) {}；
    
15.  public void windowDeactivated(WindowEvent e){}；
    
16. public void windowDeiconified(WindowEvent e){}；
    
17.  public void windowIconified(WindowEvent e){}；
    
18. public void windowOpened(WindowEvent e) {}；
19. /*
20. 适配器类的话，我们只要重写那些我们需要监听的事件
21. */

1. public class MyWindowAdapter extends WindowAdapter {
2. 1. public void windowClosing(WindowEvent e)  
   2.     {  
   3.         System.out.println("事件适配器,已经执行!");  
   4.         e.getWindow().dispose();//关闭窗口  
   5.         System.exit(0);  
   6.     }  
   
   
3. }
   
4. 
   

7、java虚拟机的内存区域

分为堆区，和栈区和方法区: 

栈区：在函数中定义的一些基本类型的变量和对象的引用时，都是在函数的栈内存中分配，当超过这个作用域时，他就会自动释放所占的内存空间。

堆区：用来存放new出来的对象或数组，在堆中分配的内存会被虚拟机自动回收，在栈中可以定义一个特殊的变量，取值等于数组或对象在堆中的首地址。

以后就可以用栈内存中的引用变量来访问堆中的数组和对象。

引用变量超过作用域时就会被回收，而数组和对象是在堆中的，就算超过他所在的代码块也不会释放，只有当没有引用变量指向他们的时候才会变成垃圾，

不能再被使用，但是仍占着内存，在随后的一个不确定的时间里被垃圾回收器回收释放掉。

.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。 
.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。 

这四个修饰符的访问权限如下表: 
----------------------------------------------- 
                        类内部     package内       子类         其他 
public             允许         允许                 允许         允许 
protected       允许         允许                 允许         不允许 
default           允许         允许                 不允许     不允许 
private           允许         不允许             不允许     不允许 
-----------------------------------------------