StringTokenizer类提供三种形式的构造函数：
1) StringTokenizer(String str)
在对一个字符串进行解析的时候，在字符串中必须包括一个用于解析的分隔符号。Java置默认的分隔符为空格、
制表符('\t')、换行符('\n')、回车符('\r')。
   StringTokenizer st = new StringTokenizer("this is a test\nmytest");
 while (st.hasMoreTokens()) {
     System.out.println(st.nextToken());
   }
输出：
this
is
a
test
mytest
2) StringTokenizer(String sb，String delim)
在程序计中想采用自定义的分隔符，可以通过在构造函数中指定delim项来设置用户分隔符。
3) StringTokenizer(String Sb，String delim，boolean returnTokens)
如果 returnTokens 标志为 true, 则分隔符字符也被作为标记返回。每个分隔符作为长度为一的字符串返回。
如果标志为 false, 则跳过分隔符字符，且把它作为标记之间的分隔符。

另外，StringTokenizer可以用String类的split函数代替
String str="abc;bcd;efg";
   String[] splitStrs=str.split(";");
   for(int i=0;i<splitStrs.length;i++)
      System.out.println(splitStrs[i]);

线程的创建方式有：
1)
//通过继承Thread实现创建进程
public class MyThread extends Thread {
  public static void main(String[] args) {
 int count = 0;
 MyThread p = new MyThread();
 p.start();
 while(true){
    try{
  p.sleep(1000);
  count++;
  System.out.println(count+",,,,,,");
  }catch(Exception ex) {
   ex.printStackTrace();
   } 
  }
 }

2)
//通过实现接口Runnable创建进程(该方法必须复写run()方法)
public class MyThread implements Runnable {
  public static void main(String[] args) {
 Thread p = new Thread(new MyThread());
 try{
      p.start();
      int count = 0;
      while(true){
  p.sleep(1000);
  count++;
  System.out.println(count+",,,,,,"); }
  }catch(Exception ex) {
    ex.printStackTrace();
  }
 }
 public void run() {
 }
}

线程有四个状态，可以为创建(new)、就绪(runnable)、阻塞（blocked）和死亡（dead）四个状态
线程的方法：
sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。
suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。

1、作用域public,private,protected,以及不写时的区别
作用域       当前类      同一package      子孙类       其他package
public         √            √             √              √
protected      √            √             √              ×
friendly       √            √             ×              ×
private        √            ×             ×              ×
不写时默认为friendly

2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
　　答：匿名的内部类是没有名字的内部类。可以继承抽象(SDK1.5没有限制)，但一个内部类可以作为一个接口，由另一个内部类实现

3、&和&&的区别
　　答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）

4、Collection 和 Collections的区别
　　答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

5、什么时候用assert
　 答：assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，
   assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；
   如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。
   一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。
   为了提高性能，在软件发布后，assertion检查通常是关闭的

6、String s = new String("xyz");创建了几个String Object 
   答：2个

7、Math.round(11.5)等於多少? Math.round(-11.5)等於多少
   答：Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor，
   函数为向下取整，Math.round(-11.5) = Math.floor(-11.5+0.5)

8、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
　　答：short s1 = 1; s1 = s1 + 1; 错（s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译）
9、Java有没有goto
　　答：java中的保留字，现在没有在java中使用

10、数组有没有length()这个方法? String有没有length()这个方法
　　答：数组没有length()这个方法，有length的属性。String有length()这个方法

11、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别
　　答：Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。

12、给我一个你最常见到的runtime exception(运行异常)
    IllegalArgumentException，IndexOutOfBoundsException，NullPointerException。

13、error和exception有什么区别
　　答：error 表示恢复不是不可能但很困难的情况下的一种严重问题，比如说内存溢出，不可能指望程序能处理这样的情况；
        exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

14、List, Set, Map是否继承自Collection接口
　　答：List，Set是，Map不是

15、abstract class和interface有什么区别？
　　答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多实现的功能)。

16、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized
　　答：都不能

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

18、构造器Constructor是否可被override
　　答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading

19、是否可以继承String类
　　答：String类是final类故不可以继承

20、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后
　　答：会执行，在return前执行

21、用最有效率的方法算出2乘以8等於几
　　答：2 << 3

22、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对
　　答：不对，有相同的hash code

23、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，
    那么这里到底是值传递还是引用传递
　　答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。
    对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的

24、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
　　答：switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。
    long,string 都不能作用于swtich

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

26、char型变量中能不能存贮一个中文汉字?为什么?
　　答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
 如果用gbk的本地编码的话可以.如果用utf-8的话，可能不行。

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

28、float型float f=3.4是否正确?
　　答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4; float f = 3.4f;

29、STRING与STRINGBUFFER的区别。
　　答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，
    那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

30、面向对象的特征有哪些方面
　　答：主要有以下四方面：
　　1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，
    而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
　　2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
    对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），
    而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，
    并且类可以修改或增加新的方法使之更适合特殊的需要。
　　3.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，
    即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
　　4. 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。
    多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

31、String是最基本的数据类型吗
　　答：不是，基本数据类型包括byte、int、char、long、float、double、boolean和short。

答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。
　　Int是java的原始数据类型，Integer是java为int提供的wapper。Java为每个原始类型提供了封装类。

32、heap和stack有什么区别
　　答：栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素

33、描述一下JVM加载class文件的原理机制?
　　答：JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。
    它负责在运行时查找和装入类文件的类。

34、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
　　答：字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。

35、java中会存在内存泄漏吗，请简单描述。
　　答：会。自己实现堆载的数据结构时有可能会出现内存泄露。

36、什么是java序列化，如何实现java序列化？
　　答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，
    也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

37、写clone()方法时，通常都有一行代码，是什么？
　　答：Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。

38、在JAVA中，如何跳出当前的多重嵌套循环？
　　答：用break; return 方法。

39、说出一些常用的类，包，接口，请各举5个
　　答：常用的类：BufferedReader  BufferedWriter  FileReader  FileWirter  String  Integer
　　常用的包：java.lang  java.awt  java.io  java.util  java.sql
　　常用的接口：Remote  List  Map  Runnable Serializable ActionListener

40、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法?
　　答：有两种实现方法，分别是继承Thread类与实现Runnable接口

41、sleep() 和 wait() 有什么区别?
　　答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，
    到时后会自动恢复。调用sleep不会释放对象锁。
　　wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，
    只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

42、启动一个线程是用run()还是start()?
　　答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。
    这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

43、线程的基本概念、线程的基本状态以及状态之间的关系
　　答：线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。
　　Java中的线程有四种状态分别是：运行、就绪、挂起、结束

//两个student对象
Student stu1=new Student(19,"zhangsan",25,"Chemist");
Student stu2=new Student(20,"lis",30,"Physics");

//将stu1和stu2写入student.txt文件中  
FileOutputStream fos=new FileOutputStream("student.txt");
ObjectOutputStream os=new ObjectOutputStream(fos);
os.writeObject(stu1);
os.writeObject(stu2);
os.close();

//从student.txt文件中读出stu3和stu4
Student stu3 = null;
Student stu4 = null;
FileInputStream fis=new FileInputStream("student.txt");
ObjectInputStream is=new ObjectInputStream(fis);
stu3=(Student)is.readObject();
stu4=(Student)is.readObject();
is.close();

1．浅复制与深复制概念
1) 浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

2)深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

2．Java的clone()方法
1) clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals 应该成立。

2)Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。

浅拷贝和深拷贝区别:
class A {  
    public   int   i;  
    public   int   j;  
  }    
  A   a   =   new   A();    
  浅拷贝：  
  A   a1   =   a;    
  深拷贝：  
  A   a1   =   new   A();  
  a1.i   =   a.i;  
  a1.j   =   a.j;  

浅复制(影子克隆):只复制对象的基本类型,对象类型,仍属于原来的引用.  
            深复制(深度克隆):不紧复制对象的基本类,同时也复制原对象中的对象.就是说完全是新对象产生的.

例1：
private String name;
 private int age;
 
 public static void main(String[] args) {
  CloneTest stu1 = new CloneTest();
  stu1.setName("aaaaaaa");
  stu1.setAge(18);
  CloneTest stu2 =(CloneTest)stu1.clone();
  stu2.setName("bbbbb");//修改学生2后，不影响学生1的值。
  System.out.println(stu2.getName());
  System.out.println(stu2.getAge());
  System.out.println(stu1.getName());
  System.out.println(stu1.getAge());
 }
 public Object clone()
    {
        Object o=null;
        try
        {
        o=(CloneTest)super.clone();//Object中的clone()识别出你要复制的是哪一个对象。
        }
        catch(CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
        return o;
    }

例2：
对象
 public Object deepClone() throws Exception
{
 //将对象写到流里
 ByteArrayOutputStream bo=new ByteArrayOutputStream();
 ObjectOutputStream oo=new ObjectOutputStream(bo);
 oo.writeObject(this);
 //从流里读出来
 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
 ObjectInputStream oi=new ObjectInputStream(bi);
 return(oi.readObject());
}

//读文件,每次读一行
1)String s2 = new String();
 try{
 BufferedReader in = new BufferedReader( new FileReader("Degree.txt"));
 String s = new String();
 int j=0;
 while((s = in.readLine()) != null)
 {
 //处理..............
 }
 in.close();
     }catch(Exception ex){
 ex.printStackTrace();
     }

2)//读文件,每次读一个字符
StringBuffer br =new StringBuffer();
int i;
 try
 {
 FileInputStream cin =new FileInputStream("1.text");    
 while((i=cin.read())!=-1){
  br.append((char)i);
  }
 }catch (Exception e){
 ex.printStackTrace();
}
r=br.toString();
System.out.println(r);

//写文件
String[] s ={"123","456","789"};
try {
 FileWriter cout = new FileWriter("Employee.txt");
 cout.write(s[0]);
 cout.write("\r\n");
 cout.write(s[1]);
 cout.write("\r\n");
 cout.write(s[2]);
 cout.flush();
 cout.close();
 } catch (Exception e) {
 e.printStackTrace();
 }
}
//写文件
String s2="123\n456\n789";
 String s;
 try{
 BufferedReader in4 =new BufferedReader(new StringReader(s2));
 PrintWriter out1 =new PrintWriter(new BufferedWriter(new FileWriter("aa.text")));
 int lineCount = 1;
 while((s = in4.readLine()) != null){
 out1.println(lineCount++ + "：" + s);
 }
 out1.close();
 in4.close();
 }catch(Exception ex){
 System.out.println("End of stream"); 
}

首先谈谈String和StringBuffer类的区别：
一个String型变量一旦经过初始化，就不能被改变了。为什么它作为一个变量而又不能被改变呢？
其实变量只是一个代表某个内存区域的引用符号，用来访问或修改它所指向的内存空间。
在String型变量的情况下，String型变量所指向的内存空间中的内容是不能被改变的，这是Java语言规范规定的。
但是该变量可用于指向另外的内存空间。例如：
String s=new String("Hello")；
s=“Hello World”；  //现在s指向内存中的新位置
在实际应用中，经常会遇到对字符串内容进行动态修改。在这种情况下，String类在功能受到限制。
Java提供了StringBuffer类来实现对字符串内容进行动态修改功能。根据StringBuffer类中提供成员方法分类，
StringBuffer类主要用于完成字符串的动态添加、插入、替换等操作。

String类的主要方法：
String类提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。
在这些方法中，按用途来分，可以分为字符串长度计算、字符串比较、字符串检索、字符串的截取、替换等方法
StringBuffer类的主要方法:
1) append() 该功能主要由StringBuffer类中成员方法append完成，其作用就是将一个字符添加到另一个字符串缓冲区的后面。
   在应用中，如果添加字符的长度超过字符串缓冲区的的长度，则字符串缓冲区自动将长度进行扩充。
2) insert方法 字符串缓冲区StringBuffer的插入操作主要用于动态地向StringBuffer中添加字符。
3) toString() 实现字符串缓冲区与字符串之间的转换
4) charAt(int index)取得指定位置的字符。
5) getChars(int srcBegin，int srcEnd，char[] dst，int dstBegin)
   赋值指定位置的字符到字符串数组dst. 无返回值。
  下面的代码段为getChars方法的例子：
   StringBuffer sbfSource=new StringBuffer("You are the best!")；
   char[] str；
   sbfSource.getChars(0,2,str,0)； // "Yo"
6) delete(int start，int end)
   删除字符串缓冲区中起始序号为start、终止序号为end-1的字符，方法的返回类型为StringBuffer。
   StringBuffer sbfSource=new StringBuffer("You are the best")；
   sbfSource.delete(0,3)；  // are the best!
7) deleteCharAt(int index)
   删除字符串缓冲区中指定位置的字符，方法的返回类型为StringBuffer
8) public StringBuffer  replace(int start,int end,String str)
   将字符串缓冲区中起始位置为start、终止位置为end的字符替换为由字符串str指定的内容，方法返回类型为StringBuffer。
9) publuc String substring(int start,int end)
   取得字符串缓冲区中起始位置为start、终止位置为end的内容，方法返回类型为String
10) publuc String substring(int start)
   取得字符串缓冲区中从起始位置为start直至字符串缓冲区结束的所有字符，方法还回类型为String
11) reverse() 将字符串序列进行反转,结果为StringBuffer。
12) capacity() 用于得到目前字符串缓冲区的剩余长度，该方法的返回类型为整数。
13) public int length() 用于得到字符串缓冲区的长度。该方法的返回类型为整数。

//HashMap的使用
private HashMap<String,Object> mapDegree;      //放入Degree的数据

public static void main(String[] args) {
 HashMapTest a = new HashMapTest();
 a.hashMap();
 a.hashMapTest("0001");
 a.hashMapTest("0002");
 a.hashMapTest("0003");
 a.hashMapTest("000");
}
 public void hashMap()
 {
 String [] degree = {"123","456","aaa"};
 mapDegree = new HashMap<String,Object>();//初始化
 //添加数据
 mapDegree.put("0001", degree[0]); 
 mapDegree.put("0002", degree[1]);
 mapDegree.put("0003", degree[2]);
 }
 //通过key取得所对应的值
public void hashMapTest(String key)
 {
  if(mapDegree.get(key)==null){
  System.out.println(key);
  }
  if(mapDegree.get(key)!=null){
  System.out.println(mapDegree.get(key));
  }
}

String类型转换为long类型的几种方法有:
Long.getLong( String nm );
Long.parseLong( String nm );
Long.valueOf( String nm );

long类型转换为字符串性
long a =12345L;
String b;
b = String.valueOf(a);

字符串转换为int类型
String a ="12345";
int b =Integer.parseInt(a);
或者
String a ="12345";
int b =Integer.valueOf(a);

//date转化为字符串
String pattern = null;
Date a = new Date();
pattern = "yyyy-mm-dd hh:mm";//转化样式
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
String resrult = sdf.format(a);

pattern可以为各种格式，yyyy表示年，mm表示月份，dd表示天数，hh表示小时，mm表示分钟(当有hh时才有效，否则认为是月份)

//String转化为日期
String str ="2008-08-08";
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date b = sdf1.parse(str,(new ParsePosition(0)));

"yyyy-MM-dd"为转换格式，yyyy表示年，mm表示月份，dd表示天数，hh表示小时，mm表示分钟(当有hh时才有效，否则认为是月份)
(new ParsePosition(0))表示从字符串第一个开始分析