震撼，java面试题整合（良心制作）11万多字拿去。持续更新可以收藏jason的java世界

不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的。

基本数据类型包括byte、int、char、long、float、double、boolean和short。

所以String不属于基本数据类型范畴内，但String属于最常见一种引用类型。

类

接口

数组

分为两种，一种是本类的初始化，一种是含有父类的初始化顺序。这里分开来说，

本类的初始化顺序是：静态变量、静态初始化块、变量、初始化块、构造函数

继承类的初始化顺序是：父类静态变量、父类静态初始化块、子类静态变量、子类静态初始块、父类变量、父类初始化块、父类构造函数、子类变量、子类初始化块、子类构造函数。

【分析】

static{System.out.println("静态块");}{System.out.println("初始化模块");}publicClassName(){System.out.println("构造方法");}

说明：

原则上回答全面的话，应该是完整的说出带有继承的这种类的初始化过程，下面有个步骤可以参考：

此题主要考查集合框架的知识。在集合框架中Collection接口为集合的根类型，提供集合操作的常用API方法，该接口下派生出两个子接口，一个是不支持排序的List接口，一个是有自身排序的Set接口，所以回答排序与不排序分别从两接口的实现中在作答。线程安全上来说，Vector类比同属于List接口的ArrayList要早，是一个线程安全的类，在JDK1.2以后才推出一个异步的ArrayList类，比Vector类效率高。同理Stack继承自Vector也线程安全的类，另外在在Map接口的实现在Hashtable也是个线程安全的类。

一是继承Thread，重写Thread类的方法run方法；另种是实现runnable接口并实现run方法。

考查线程的基本实现，很多公司喜欢考查这方面知识，另外补充一下关于线程的run方法，在多线程API中启动一个线程是调用start()方法，线程进入就绪状态。

stop()是因为它不安全。它会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，假如一个线程正在执行：synchronizedvoid{x=3;y=4;}由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x=3;时，被调用了stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记线程的stop方法，以后我们再也不要说“停止线程”了。而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。

suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objetobj=newObject();变量obj是一个内存，newObject()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：

Stringa=newString("foo");

Stringb=newString("foo");

两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，Stringinput=…;input.equals(“quit”)，如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

booleanequals(Objecto){

returnthis==o;

}

这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

publicclassVariantTest

{

publicstaticintstaticVar=0;

publicintinstanceVar=0;

publicVariantTest()

staticVar++;

instanceVar++;

System.out.println(“staticVar=”+staticVar+”,instanceVar=”+instanceVar);

备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！

构造器的名称必须与类名相同。

构造器或构造函数（有些书这样叫）主要用来对类的成员变量进行初始化，当类创建实例时调用。

不可以调用。因为Java的主方法（main）方法本身也是static类型方法，一个static类型方法，发起对另一个static方法的调用没有问题。

静态方法可以调用其它的静态方法，但是不能调用非静态方法，这个好比Java中的类变量与实例变量的关系。类变量是被所有类成员共享，而实例变量只被该实例共享，

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

运行时异常是程序运行时可能报出的异常。可以用trycatch抓取，也可以不做任何处理。例如：NullPointerException异常就是一种比较常见的运行时异常。

int是java提供的8种原始数据类型之一，另外Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。

JAVA反射，Reflection是Java程序开发语言的特征之一，它允许运行中的Java程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。

主要有equals()、toString()、getClass()、hashCode()、clone()、notify()、wait()、notify()方法。

这种题能记多少个就说多少个，不一定要求你所有的都记住，但是要理解其中部分重要方法的含义和作用。

&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位。

先说分别说两者的作用，再说出&&和&各自的不同之处。

数组没有length()方法，但有length属性String有length()方法。

考查平时使用数组和字符串的一些细节，一般在使用

2个string对象,一个是=null的s，一个是=“xyz”的string

两个或一个”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。NewString每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

ClassCastException（类型转换异常）、NumberFormatException（格式化异常）、

ArrayIndexOutOfBoundsException（数组越界异常）、ArithmeticException（算术异常）、NullPointerException（空指针异常）等等

这道题主要考查大家平时在项目开发过程中经常遇到的一些异常类型信息，通过这些异常来考查大家的项目经验与项目排错能力。

1、通过驱动器管理器获取连接接口（Connection）。

2、获得Statement或它的子类。

3、指定Statement中的参数。

4、通过Statement发送SQL语句。

5、检查并处理返回的结果。

6、关闭Statement。

7、关闭连接接

error表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等，不可能指望程序能处理的一类错误。Exception表示一种由程序设计或实现问题，像我们常说的异常处理，就是属于这类，一般程序可以捕获和处理这些异常。

这道题的难点在Error很多时候由于我们无法重现这种Error导致很多同学甚至不知道Error到底是什么，所以很容易把题目中的两种错误划上等号。

面向对象的编程语言有封装、继承、多态等3个主要的特征。

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。

在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。

运行jvm字符码的工作是由解释器来完成的。解释执行过程分三步进行：

代码的装入、代码的校验、和代码的执行。

装入代码的工作由“类装载器classloader”完成。类装载器负责装入运行一个程序需要的所有代码，这也包括程序代码中的类所继承的类和被调用的类。当类装载器装入一个类时，该类被放在自己的名字空间中。除了通过符号引用自己名字空间以外的类，类之间没有其他办法可以影响其他类。在本台计算机的所有类都在同一地址空间中，而所有从外部引进的类，都有一个自己独立的名字空间。这使得本地类通过共享相同的名字空间获得较高的运行效率，同时又保证它们与从外部引进的类不会相互影响。当装入了运行程序需要的所有类后，解释器便可确定整个可执行程序的内存布局。解释器为符号引用与特定的地址空间建立对应关系及查询表。通过在这一阶段确定代码的内布局，java很好地解决了由超类改变而使子类

崩溃的问题，同时也防止了代码的非法访问。随后，被装入的代码由字节码校验器进行检查。校验器可以发现操作数栈益处、非法数据类型转化等多种错误。通过校验后，代码便开始执行了。

Java字节码的执行有两种方式：

1）即时编译方式：解释器先将字节编译成机器码，然后再执行该机器码。

2）解释执行方式：解释器通过每次解释并执行一小段代码来完成java字节。

码程序的所有操作。

Java把内存分成两种，一种叫做栈内存，一种叫做堆内存

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作它用。

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用

比如classAextendsBimplementsC,D,E

可以在java中用abstract关键字来修饰一个类时，这个类叫做抽象类。

静态的多态:即为重载；方法名相同，参数个数或类型不相同。(overloading)

动态的多态:即为重写；子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法实现接口的实例传与接口的引用调用的实现类的方法。

常用的类：String、StringBuffer、Integer、Vector、ArrayList、Hashtable等

常用的包：java.langjava.iojava.util、java.sql。

Collection是个java.util下的接口，它是各种集合结构的父接口，定义了集合对象的基本操作方法。Collections是个java.util下的工具类，它包含有各种有关集合操作的静态方法，主要是针对集合类的一个帮助类或者叫包装类，它提供一系列对各种集合的搜索，排序，线程安全化等操作方法。

按参数中指定的字符串形式的类名去搜索并加载相应的类，如果该类字节码已经被加载过，则返回代表该字节码的Class实例对象，否则，按类加载器的委托机制去搜索和加载该类，如果所有的类加载器都无法加载到该类，则抛出ClassNotFoundException。加载完这个Class字节码后，接着就可以使用Class字节码的newInstance方法去创建该类的实例对象了。有时候，我们程序中所有使用的具体类名在设计时（即开发时）无法确定，只有程序运行时才能确定，这时候就需要使用Class.forName去动态加载该类，这个类名通常是在配置文件中配置的，例如，spring的ioc中每次依赖注入的具体类就是这样配置的，jdbc的驱动类名通常也是通过配置文件来配置的，以便在产品交付使用后不用修改源程序就可以更换驱动类名。

接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承具体类。抽象类中可以有静态的main方法。

备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是java语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。

只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

clone有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

通常我们使用的集合类都大多是由List、Set、Map这三类接口派生出来的类，例如：

ArrayList、Vector、LinkedList、Stack、TreeSet、Hashtable、HashMap等

集合类的大部分方法都是由Collection接口定义的，主要包括有：

add(Ee)、remove(Objecte)、addAll(),remove()、contains(Objectobj)、clear()等

这四个作用域的可见范围如下表所示。

说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly。

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

public√√√√

protected√√√×

friendly√√××

private√×××

备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。

Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整，所以，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，所以，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstractclass，abstractclass类中的方法不必是抽象的。abstractclass类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为publicabstract类型，接口中的成员变量类型默认为publicstaticfinal。

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型。

5.抽象类中可以包含静态方法，接口中不能包含静态方法

6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是publicstaticfinal类型，并且默认即为publicstaticfinal类型。

7.一个类可以实现多个接口，但只能继承一个抽象类。

下面接着再说说两者在应用上的区别：

这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等方面来回答。

Comparable、Comparator接口

String类是final类故不可以继承。

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。String类表示内容不可改变的字符串。而StringBuffer类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，newString(“abc”).equals(newString(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，newStringBuffer(“abc”).equals(newStringBuffer(“abc”)的结果为false。

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。

StringBuffer和StringBuilder类都表示内容可以被修改的字符串，StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用StringBuffer。

答案是在return之前。

程序代码的运行结果：

publicclassTest{

publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

System.out.println(newTest().test());;

staticinttest()

intx=1;

try

returnx;

finally

++x;

---------执行结果---------

1

运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。

下面的程序代码输出的结果是多少？

publicclasssmallT

publicstaticvoidmain(Stringargs[])

smallTt=newsmallT();

intb=t.get();

System.out.println(b);

publicintget()

return1;

return2;

返回的结果是2。

我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

在讲解答案时可以用下面的程序来帮助分析：

/**

*@paramargsaddbyzxx,Dec9,2008

*/

inttest()

returnfunc1();

returnfunc2();

intfunc1()

System.out.println("func1");

intfunc2()

System.out.println("func2");

-----------执行结果-----------------

func1

func2

2

结论：finally中的代码比return和break语句后执行。

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口。

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

启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员。

一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。

这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，并且其中的数据是允许重复的。

接着说ArrayList与Vector的区别，这主要包括两个方面：1、同步性：

Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。

备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。2、数据增长：

ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长为原来的1.5倍。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。

Java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用

new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使

用final修饰后，放在堆中，而不是栈中。

java.io.Serializable接口或实现Externalizable接口。

Collection框架中实现比较要实现Comparable接口或Comparator接口，并实现比较方法

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

序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implementsSerializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，使用ObjectOutputStream对象的writeObject(Objectobj)方法就可以将参数为obj的对象写出,那么在另一端，通过ObjectInputStream对象的readObject(Objectobj)获取到字节流数据后，要将字节流转换成原对象，这叫反序列化,以便将数据存储在文件中或在网络传输。

Serializable接口描述启用其序列化功能，未实现此接口的类将无法使其任何状态序列化或反序列化。Serializable接口没有方法或字段，仅用于标识可序列化的语义，标识实现了该接口的对象属性可被序列化。

Sockets有两种主要的操作方式:面向连接(TCP/IP)的和无连接(UDP)的。无连接的操作使用数据报协议，无连接的操作是快速的和高效的,但是数据安全性不佳.面向连接的操作使用TCP协议.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高

抽象类一般不能被实例化；抽象类通常不是由程序员定义的，而是由项目经理或模块设计人设计抽象类的原因通常是为了规范方法名抽象类必须要继承，不然没法用，作为模块设计者，可以把让底层程序员直接用得方法直接调用，而一些需要让程序员覆盖后自己做得方法则定义称抽象方法

而LinkedList的内部实现是基于一组双向链表实现的存储特性，所以提供了链表一样访问的API接口，它们在性能上有很大的差别。当你访问Linkedlist链表中的某个元素时，就必须从链表的一端开始沿着连接方向一个一个元素地去查找，直到找到所需的元素为止，所以，当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。

而当你的操作是在一列数据的后面添加数据而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能。

通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址

预编译语句java.sql.PreparedStatement,扩展自Statement,不但具有Statement的所有能力而且具有更强大的功能。不同的是，PreparedStatement是在创建语句对象的同时给出要执行的sql语句。这样，sql语句就会被系统进行预编译，执行的速度会有所增加，尤其是在执行大语句的时候，效果更加理想

Reflection:是Java被视为动态语言的一个关键性质。这个机制允许程序在运行时透过ReflectionAPIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public,static等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。

序列化:就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时的问题。

重写，重载

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

Overload是重载的意思，Override是覆盖的意思，也就是重写。

重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

是否可以改变返回值类型，在重载的定义中，与方法是什么类型返回值无关。

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

jvm里有多个类加载，每个类加载可以负责加载特定位置的类，例如，bootstrap类加载负责加载jre/lib/rt.jar中的类，我们平时用的jdk中的类都位于rt.jar中。extclassloader负责加载jar/lib/ext/*.jar中的类，appclassloader负责classpath指定的目录或jar中的类。除了bootstrap之外，其他的类加载器本身也都是java类，它们的父类是ClassLoader。

实现Comparable比较接口，并实现compareTo方法。排序的方法，取决于compareTo方法中的比较定义的返回值,一般有3个返回值：1、-1、0表示不同的比较结果。

程序示例：

classMyBeanimplementsComparable{

publicintcompareTo(Objectobj){

if(!objinstanceofMyBean)

thrownewClassCastException();

MyBeanother=(MyBean)obj;

returnage>other.age1:age==other.age0:-1;

classMyTreeSet{

privateArrayListdatas=newArrayList();

publicvoidadd(Objectobj){

for(inti=0;i

if(obj.compareTo(datas.get(i)!=1){

datas.add(i,obj);

hashcode这个方法是用来鉴定2个对象是否相等的。hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码。我们一般在覆盖equals的同时也要覆盖hashcode，让他们的逻辑一致。

abstract的method不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！

privatenativevoidopen(Stringname)throwsFileNotFoundException;

关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。

可以继承其他类或实现其他接口。不仅是可以，而是必须!

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

分几种情况：

1.其他方法前是否加了synchronized关键字，如果没加，则能。

2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。

3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。

4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。

状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。

调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都实现Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Mapinterface的一个实现。

最大的不同是，Hashtable的方法是synchronized的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

List、Set是，Map不是；Map接口定义的是Key-Value存储的特性，与List和Set不同，Map在存储对象时，先要定义这个对象的key的值，再存入与这个key相对应的Object，Map集合的取值时根据存入的key（关键字）来获取与这个关键字对应的对象。

首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口Collection接口。Set里面不允许有重复的元素，即不能有两个相等的对象。

List表示有先后顺序的集合，当我们多次调用add(Obje)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。

Map与List和Set不同，它是双列的集合每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Objectkey)返回值为key所对应的value。另外，也可以获得所有的key的结合。

总结：List以特定次序来持有元素，可有重复元素。Set无法拥有重复元素,内部排序。Map保存key-value值，value可多值。上面是大致不同，另外上述3个只是接口，而具体实现类中，用法大同小异，只是实现的数据结构不同，例如List接口下的LinkedList主要实现了双链表的存储特点，Vector是线程安全的集合类。

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

LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。

VectornewVector=newVector();

for(inti=0;i

Objectobj=vector.get(i);

if(!newVector.contains(obj);

newVector.add(obj);

还有一种简单的方式，HashSetset=newHashSet(vector);

Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。

对。

如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。

如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode方法。

要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。

在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。

底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。

字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，

其实是转成该字符的某种编码的字节形式，读取也是反之的道理。

讲解字节流与字符流关系的代码案例：

importjava.io.BufferedReader;

importjava.io.FileInputStream;

importjava.io.FileOutputStream;

importjava.io.FileReader;

importjava.io.FileWriter;

importjava.io.InputStreamReader;

importjava.io.PrintWriter;

publicclassIOTest{

publicstaticvoidmain(String[]args)throwsException{

Stringstr="中国人";

/*FileOutputStreamfos=newFileOutputStream("1.txt");

fos.write(str.getBytes("UTF-8"));

fos.close();*/

/*FileWriterfw=newFileWriter("1.txt");

fw.write(str);

fw.close();*/

PrintWriterpw=newPrintWriter("1.txt","utf-8");

pw.write(str);

pw.close();

/*FileReaderfr=newFileReader("1.txt");

char[]buf=newchar[1024];

intlen=fr.read(buf);

StringmyStr=newString(buf,0,len);

System.out.println(myStr);*/

/*FileInputStreamfr=newFileInputStream("1.txt");

byte[]buf=newbyte[1024];

StringmyStr=newString(buf,0,len,"UTF-8");

BufferedReaderbr=newBufferedReader(

newInputStreamReader(

newFileInputStream("1.txt"),"UTF-8"

)

);

StringmyStr=br.readLine();

br.close();

System.out.println(myStr);

1、JavaNIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。

2、JavaIO的各种流是阻塞的。而JavaNIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。

3、选择器上，JavaIO无选择器，而NIO有选择器，JavaNIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象变成了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的，例如下面的代码可以看到这种情况的内存回收：

packagecom.huawei.interview;

importjava.io.IOException;

publicclassGarbageTest{

*@paramargs

*@throwsIOException

publicstaticvoidmain(String[]args)throwsIOException{

try{

gcTest();

}catch(IOExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

System.out.println("hasexitedgcTest!");

System.in.read();

System.out.println("outbegingc!");

for(inti=0;i<100;i++)

System.gc();

privatestaticvoidgcTest()throwsIOException{

Personp1=newPerson();

Personp2=newPerson();

p1.setMate(p2);

p2.setMate(p1);

System.out.println("beforeexitgctest!");

System.out.println("exitgctest!");

privatestaticclassPerson

byte[]data=newbyte[20000000];

Personmate=null;

publicvoidsetMate(Personother)

mate=other;

java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

[]是对象已不可到达，而内存又没有回收，真正的内存黑洞。而Java的泄漏，则是因为各种原因，对象对应用已经无用，但一直被持有，一直可到达。总结原因无外乎几方面：

内存泄漏的检测

有不少工具辅助做这个事情的，如果手上一个工具也没有，可以用JDK自带的小工具：

首先equals()和hashcode()这两个方法都是从object类中继承过来的，主要用来比较对象时进行调用。在object类中定义如下：

答：threadlocal是线程局部变量（threadlocalvariable），为每一个使用该线程的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本产生冲突。

TCP/IP的运输层有两个不同的协议：①用户数据报协议UDP②传输控制协议TCP

二者最大区别:TCP是面向连接的,而UDP是无连接的.区别大致如下:

1）UDP传送的数据单位协议是UDP报文或用户数据报,TCP传送的数据单位协议是TCP报文段。

2）UDP发送数据之前不需要建立连接,因此减少了开销和发送之前的时延。TCP提供面向连接的服务,不提供广播或多播服务。

3）对方的运输层在收到UDP报文后,不需要给出任何确认。TCP则需要确认。

4）UDP没有拥塞控制,因此网络出现的拥塞不会使源主机的发送速率降低,也不保证可靠交付,因此主机不需要维持具有许多参数的、复杂的连接状态表。TCP要提供可靠的、面向连接的运输服务,因此不可避免地增加了许多的开销,这不仅使协议数据单元的首部增大很多,还要占用许多的处理机资源。

5）UDP用户数据报只有8个字节的首部开销,比TCP的20个字节的首部要短。

【参考】

使用Thread类的start()方法来启动一个线程，使线程进入就绪状态。如果自定义的类是Thread类的子类的话，可以直接使用Start()来启，如果是实现的Runnable接口的话，还要将该类的实例作为参数传入到Thread对象中来启动。

作用域不写将采用默认的作用域,默认作用域的访问权限是包的权限，也就是除本包中的所有类能访问，不同包只有子类能访问。

用static修饰的方法叫类方法，被所有实例共享；static修饰的字段为类变量，被所有实例共享，在使用类变量时，一般会结合final一起使用定义类常量，不允许被其它的类实例修改。

可以被重载，重载只是参数类型、顺序和个数不同。

publicstaticvoidBubble(inta[]){

for(inti=0;i

for(intj=a.length-1;j>i;j--){

if(a[j]

a[j]=a[j]+a[j-1];

a[j-1]=a[j]-a[j-1];

a[j]=a[j]-a[j-1];

最终的程序代码如下：

publicclassThreadTest{

newThreadTest().init();

publicvoidinit()

finalBusinessbusiness=newBusiness();

newThread(

newRunnable()

publicvoidrun(){

for(inti=0;i<50;i++)

business.SubThread(i);

).start();

business.MainThread(i);

privateclassBusiness

booleanbShouldSub=true;//这里相当于定义了控制该谁执行的一个信号灯

publicsynchronizedvoidMainThread(inti)

if(bShouldSub)

this.wait();

}catch(InterruptedExceptione){

for(intj=0;j<5;j++)

System.out.println(Thread.currentThread().getName()+":i="+i+",j="+j);

bShouldSub=true;

this.notify();

publicsynchronizedvoidSubThread(inti)

if(!bShouldSub)

for(intj=0;j<10;j++)

bShouldSub=false;

备注：不可能一上来就写出上面的完整代码，最初写出来的代码如下，问题在于两个线程的代码要参照同一个变量，即这两个线程的代码要共享数据，所以，把这两个线程的执行代码搬到同一个类中去：

packagecom.huawei.interview.lym;

privatestaticbooleanbShouldMain=false;

/*newThread(){

publicvoidrun()

System.out.println("i="+i+",j="+j);

}.start();*/

//finalStringstr=newString("");

synchronized(ThreadTest.class){

if(bShouldMain)

ThreadTest.class.wait();}

catch(InterruptedExceptione){

System.out.println(

Thread.currentThread().getName()+

"i="+i+",j="+j);

bShouldMain=true;

ThreadTest.class.notify();

if(!bShouldMain)

bShouldMain=false;

下面使用jdk5中的并发库来实现的：

importjava.util.concurrent.Executors;

importjava.util.concurrent.ExecutorService;

importjava.util.concurrent.locks.Lock;

importjava.util.concurrent.locks.ReentrantLock;

importjava.util.concurrent.locks.Condition;

publicclassThreadTest

privatestaticLocklock=newReentrantLock();

privatestaticConditionsubThreadCondition=lock.newCondition();

privatestaticbooleanbBhouldSubThread=false;

publicstaticvoidmain(String[]args)

ExecutorServicethreadPool=Executors.newFixedThreadPool(3);

threadPool.execute(newRunnable(){

lock.lock();

if(!bBhouldSubThread)

subThreadCondition.await();

System.out.println(Thread.currentThread().getName()+",j="+j);

bBhouldSubThread=false;

subThreadCondition.signal();

}catch(Exceptione)

lock.unlock();

});

threadPool.shutdown();

if(bBhouldSubThread)

bBhouldSubThread=true;

一个正方形里面全数字,写一个程序,成对角线转变!我做的这个是3行3列的对角互换，也许转换规则不一样

publicclasstestMain{

inta[][]=newint[3][3];

intc=1;

//初始化数据

for(inti=0;i<3;i++){

for(intj=0;j<3;j++){

a[i][j]=c++;

System.out.println("转换之前：");

System.out.print("a["+i+"]["+j+"]="+a[i][j]+"");

System.out.println("\n");

if((i+1<3&&j+1<3)&&i==j&&i!=0&&i!=3-i){

inttemp=a[i-1][j-1];

a[i-1][j-1]=a[i+1][j+1];

a[i+1][j+1]=temp;

temp=a[i-1][j+1];

a[i-1][j+1]=a[i+1][j-1];

a[i+1][j-1]=temp;

System.out.println("转换之后：");

System.out

print("a["+i+"]["+j+"]="+a[i][j]+"");

publicstaticvoidmain(String[]args){intnum=-800000000;Stringstr=Integer.toBinaryString(num);//获得num的二进制if(num>=0){//如果输入的数为正数,位数可能不足32位，要补0；负数肯定是32位if(str.length()<32){//二进制不足32位，就在前面补0intn0=32-str.length();//看差几个0Stringtemp="";for(inti=0;i

以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。

publicclassThreadTest1

privateintj;

publicstaticvoidmain(Stringargs[]){

ThreadTest1tt=newThreadTest1();

Incinc=tt.newInc();

Decdec=tt.newDec();

for(inti=0;i<2;i++){

Threadt=newThread(inc);

t.start();

t=newThread(dec);

privatesynchronizedvoidinc(){

j++;

System.out.println(Thread.currentThread().getName()+"-inc:"+j);

privatesynchronizedvoiddec(){

j--;

System.out.println(Thread.currentThread().getName()+"-dec:"+j);

classIncimplementsRunnable{

for(inti=0;i<100;i++){

inc();

classDecimplementsRunnable{

dec();

----------随手再写的一个-------------

classA

JMangerj=newJManager();

main()

newA().call();

voidcall

for(inti=0;i<2;i++)

newRunnable(){publicvoidrun(){while(true){j.accumulate()}}}

newThread(newRunnable(){publicvoidrun(){while(true){j.sub()}}}).start();

classJManager

privatej=0;

publicsynchronizedvoidsubtract()

j--

publicsynchronizedvoidaccumulate()

216是16进制，转10进制:＝2*16^2+1*16^1+6*16^0=512+16+6=536

以下函数htoi函数的功能是将一个十六进制数字的字符串，转换成它等价的十进制整数值。

Publicinthtoi(chars[])

Inti,n;

N=0;

For(i=0,s[i]<’\0’;i++)

If(s[i]>=0&&s[i]<=9)n=_______

If(s[i]>=’a’&&s[i]<=’f’)n=_________

If(s[i]>=’A’&&s[i]<=’F’)n=_________

Return(n);

可以说说我的思路：

StringTokenizertokener=StringTokenizer(orgStr,”,”);

String[]result=newString[tokener.countTokens()];

Inti=0;

while(tokener.hasNext(){result[i++]=toker.nextToken();}

Stringstr=“13abf”;

intlen=str.length;

intsum=0;

for(inti=0;i

charc=str.charAt(len-1-i);

intn=Character.digit(c,16);

sum+=n*(1<<(4*i));

其实，也可以用Integer.parseInt(str,16)，但面试官很可能是想考我们的编码基本功。

Filefile=newFile("E:\\JRadioButtonDemo.java");

longfile_length=file.length();

//输入流

FileInputStreaminput=newFileInputStream(file);

byteb_data[]=newbyte[(int)file_length];

input.read(b_data);

System.out.println(newString(b_data));

input.close();

}catch(FileNotFoundExceptione){

publicstaticintFoo(inti){if(i<=0)return0;elseif(i>0&&i<=2)return1;elsereturnFoo(i-1)+Foo(i-2);}inti=Foo(30);System.out.println(i);

publicstaticvoidgetUniqueString(Stringstr){

booleanbool=true;

for(inti=0;i

Strings1=str.substring(i,i+1);

if(str.indexOf(s1,i+1)==-1){

System.out.println(s1);

bool=false;

//写一个递归函数，输入一个整数，反序输出这个整数

publicstaticvoidprintOut(intn){

System.out.print(n%10);

if(n>=10){

printOut(n/10);

publicvoidreadtext(){

Filefile=newFile("D:\test.txt");

Listlist=newArrayList();

BufferedReaderbr=newBufferedReader(newFileReader(file));

Stringdata="";

Stringline=null;

while((line=br.readLine())!=null){

data=data.concat(line);

StringTokenizerstoken=newStringTokenizer(data,"");

while(stoken.hasMoreTokens()){

inti=Integer.parseInt(stoken.nextToken());

list.add(i);

}catch(Exceptionex){}

String[]str=newString[list.size()];

for(inti=0;i

str[i]=list.get(i);

ObjectiTemp=null;

for(inti=1;i

for(intj=list.size()-1;j>=i;j--){

if(str[j]>str[j-1]){

iTemp=str[j-1];

str[j-1]=str[j];

str[j]=iTemp;

Stringresult="";

for(inti=0;i

result+=str[i]+"";

//将result写入另外一个文件即可。

publicvoidtest(){

Integer[]a=newInteger[19];

for(inti=1;i<20;i++){

a[i-1]=i;

for(inti=0;i<18;i++){

for(intj=18-i;j<18;j++)

if(a[i]+a[j]==20)

System.out.println(a[i]+"+"+a[i+1]+"="+20);

答：采用建立字典表进行查找转换publicstaticStringtranslate(Strings){Stringqj="ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ";Stringbj="ABCDEFGHIJKLMNOPQRSTUVWXYZ";StringBuffersb=newStringBuffer();for(inti=0;i=0){System.out.println(c+","+pos);sb.append(bj.charAt(pos));}else{sb.append(c);}}returnsb.toString();}

packaget1;

publicclassmystack{

privateObject[]data;

privateinttop=-1;

privateintsize;

publicmystack()

data=newObject[5];

size=5;

publicmystack(intsize)

data=newObject[size];

this.size=size;

publicvoidpush(Objectobj)

if(this.isfull())

return;

top++;

data[top]=obj;

publicObjectpop(){

if(this.isempty())

returnnull;

Objectobj=data[top];

top--;

returnobj;

publicbooleanisfull()

if(top==data.length)

returntrue;

else

returnfalse;

publicbooleanisempty()

if(top==-1)

publicvoidtest(inta,intb){

System.out.println("交换前a="+a);

System.out.println("交换前b="+b);

a=a+b;

b=a-b;

a=a-b;

System.out.println("交换后a="+a);

System.out.print("交换后b="+b);

newtestMain().test(10,13);

方法1

publicclassTest1{

publicstaticinta(int[]i,intj){

if(i.length-1>j){

if(i[j]>i[j+1]){

i[j+1]=i[j];

returna(i,j+1);

}else{

returni[i.length-1];

方法2--非递归

publicstaticinttest(int[]num){

intx=0;

intlog=num.Length;

for(intt=0;t

if(num[t]>x){

x=num[t];

}returnx;

方法3---递归不改变原数组中的元素

publicstaticintgetMax(int[]a,intindex,intmax){

intlen=a.length;

if(len==1){

returna[len-1];

if(index==0){

max=a[index];

if(index==len){

returnmax;

if(max

index++;

returngetMax(a,index,max);

//测试

intmax=getMax(newint[]{2,5,18,3,38,10,2},0,0);

System.out.println(max);

/*100以内素数*/

#include

inti,j;

for(i=2;i<100;i++)

for(j=2;j

if(i%j==0)

break;

if(i==j)

printf("%d",i);

/*分解质因数*/

intn,i;

printf("pleaseinputanumber:\n");

scanf("%d",&n);

printf("%d=",n);

for(i=2;i<=n;i++)

while(n!=i)

if(n%i==0)

printf("%d*",i);

n=n/i;

}else{break;}

printf("%d",n);

getch();

Strings=”56.89.5.3.75.98.98.26.15.44”;

Strings1[]=s.split(“.”);

Integerii[]=newInteger[s1.length];

For(inti=0;i

ii[i]=Integer.parseInt(s1[i]);

Arrays.sort(ii);

for(Integero:ii){

System.out.println(o+”s”);

0的阶乘等于1即0！＝１那么４个0就是４了

又4的阶乘为２４４！＝２４

答：我们可以用正则表达式来定义复杂的字符串格式，(\d{17}[0-9a-zA-Z]|\d{14}[0-9a-zA-Z])可以用来判断是否为合法的15位或18位身份证号码。

因为15位和18位的身份证号码都是从7位到第12位为身份证为日期类型。这样我们可以设计出更精确的正则模式，使身份证号的日期合法，这样我们的正则模式可以进一步将日期部分的正则修改为[12][0-9]{3}[01][0-9][123][0-9]，当然可以更精确的设置日期。

在jdk的java.util.Regex包中有实现正则的类,Pattern和Matcher。以下是实现代码：

importjava.util.regex.Matcher;

importjava.util.regex.Pattern;

publicclassRegexTest{

//测试是否为合法的身份证号码

String[]strs={"130681198712092019","13068119871209201x",

"13068119871209201","123456789012345","12345678901234x",

"1234567890123"};

Patternp1=Pattern.compile("(\\d{17}[0-9a-zA-Z]|\\d{14}[0-9a-zA-Z])");

for(inti=0;i

Matchermatcher=p1.matcher(strs[i]);

System.out.println(strs[i]+":"+matcher.matches());

Patternp2=Pattern.compile("\\d{6}(\\d{8}).*");//用于提取出生日字符串

Patternp3=Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");//用于将生日字符串进行分解为年月日

Matchermatcher=p2.matcher(strs[i]);

booleanb=matcher.find();

if(b){

Strings=matcher.group(1);

Matchermatcher2=p3.matcher(s);

if(matcher2.find()){

.println("生日为"+matcher2.group(1)+"年"

+matcher2.group(2)+"月"

+matcher2.group(3)+"日");

答：

packagecn.itcast;

importjava.io.File;

publicclassMainClass{

FileManagera=newFileManager("a.txt",newchar[]{'\n'});

FileManagerb=newFileManager("b.txt",newchar[]{'\n',''});

FileWriterc=newFileWriter("c.txt");

StringaWord=null;

StringbWord=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.close();

classFileManager{

String[]words=null;

intpos=0;

publicFileManager(Stringfilename,char[]seperators)throwsException{

Filef=newFile(filename);

FileReaderreader=newFileReader(f);

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

intlen=reader.read(buf);

Stringresults=newString(buf,0,len);

Stringregex=null;

if(seperators.length>1){

regex=""+seperators[0]+"|"+seperators[1];

regex=""+seperators[0];

words=results.split(regex);

publicStringnextWord(){

if(pos==words.length)

returnwords[pos++];

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

importjava.io.FilenameFilter;

importjava.io.InputStream;

importjava.io.OutputStream;

publicclassJad2Java{

FilesrcDir=newFile("java");

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

thrownewException("目录不存在");

File[]files=srcDir.listFiles(

newFilenameFilter(){

publicbooleanaccept(Filedir,Stringname){

returnname.endsWith(".java");

System.out.println(files.length);

FiledestDir=newFile("jad");

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

for(Filef:files){

FileInputStreamfis=newFileInputStream(f);

StringdestFileName=f.getName().replaceAll("\\.java$",".jad");

FileOutputStreamfos=newFileOutputStream(newFile(destDir,destFileName));

copy(fis,fos);

fis.close();

fos.close();

privatestaticvoidcopy(InputStreamips,OutputStreamops)throwsException{

intlen=0;

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

ops.write(buf,0,len);

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

1.

classjad2java{

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

1.1得到目录FilesrcDir=newFile("d:\\java");

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

1.3只想得到.java的文件：classMyFileFilterimplememytsFileFilter{

publicbooleanaccept(Filepathname){

returnpathname.getName().endsWith(".java")

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

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

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

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

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

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

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

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

File[]listFiles(FileFilterfilter){

File[]files=listFiles();

//ArraylistacceptedFilesList=newArrayList();

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

for(Filefile:files){

booleanaccepted=filter.accept(file);

if(accepted){

//acceptedFilesList.add(file);

acceptedFiles[pos++]=file;

Arrays.copyOf(acceptedFiles,pos);

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

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

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

Stringstr="我a爱中华abcdef';

Stringstr="我ABC汉";

intnum=trimGBK(str.getBytes("GBK"),5);

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

publicstaticinttrimGBK(byte[]buf,intn){

intnum=0;

booleanbChineseFirstHalf=false;

for(inti=0;i

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

bChineseFirstHalf=true;

num++;

bChineseFirstHalf=false;

returnnum;

答：Stringcontent=“中国aadf的111萨bbb菲的zz萨菲”;

HashMapmap=newHashMap();

for(inti=0;i

charc=content.charAt(i);

Integernum=map.get(c);

if(num==null)

num=1;

num=num+1;

map.put(c,num);

for(Map.EntrySetentry:map)

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

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

intengishCount;

intchineseCount;

intdigitCount;

for(inti=0;i

charch=str.charAt(i);

if(ch>=’0’&&ch<=’9’)

digitCount++

elseif((ch>=’a’&&ch<=’z’)||(ch>=’A’&&ch<=’Z’))

engishCount++;

chineseCount++;

System.out.println(……………);

1,张三,28

2,李四,35

3,张三,28

4,王五,35

5,张三,28

6,李四,35

7,赵六,28

8,田七,35

importjava.util.Comparator;

importjava.util.HashMap;

importjava.util.Iterator;

importjava.util.Map;

importjava.util.TreeSet;

publicclassGetNameTest{

//InputStreamips=GetNameTest.class.getResourceAsStream("/com/huawei/interview/info.txt");

//用上一行注释的代码和下一行的代码都可以，因为info.txt与GetNameTest类在同一包下面，所以，可以用下面的相对路径形式

Mapresults=newHashMap();

InputStreamips=GetNameTest.class.getResourceAsStream("info.txt");

BufferedReaderin=newBufferedReader(newInputStreamReader(ips));

while((line=in.readLine())!=null)

dealLine(line,results);

sortResults(results);

staticclassUser

publicStringname;

publicIntegervalue;

publicUser(Stringname,Integervalue)

this.name=name;

this.value=value;

@Override

publicbooleanequals(Objectobj){

//下面的代码没有执行，说明往treeset中增加数据时，不会使用到equals方法。

booleanresult=super.equals(obj);

System.out.println(result);

returnresult;

privatestaticvoidsortResults(Mapresults){

TreeSetsortedResults=newTreeSet(

newComparator(){

publicintcompare(Objecto1,Objecto2){

Useruser1=(User)o1;

Useruser2=(User)o2;

/*如果compareTo返回结果0，则认为两个对象相等，新的对象不会增加到集合中去

*所以，不能直接用下面的代码，否则，那些个数相同的其他姓名就打印不出来。

**/

//returnuser1.value-user2.value;

//returnuser1.value

if(user1.value

return-1;

}elseif(user1.value>user2.value)

}else

returnuser1.name.compareTo(user2.name);

Iteratoriterator=results.keySet().iterator();

while(iterator.hasNext())

Stringname=(String)iterator.next();

Integervalue=(Integer)results.get(name);

if(value>1)

sortedResults.add(newUser(name,value));

printResults(sortedResults);

privatestaticvoidprintResults(TreeSetsortedResults)

Iteratoriterator=sortedResults.iterator();

Useruser=(User)iterator.next();

System.out.println(user.name+":"+user.value);

publicstaticvoiddealLine(Stringline,Mapmap)

if(!"".equals(line.trim()))

String[]results=line.split(",");

if(results.length==3)

Stringname=results[1];

Integervalue=(Integer)map.get(name);

if(value==null)value=0;

map.put(name,value+1);

第一种：饱汉模式

publicclassSingleTon{

privateSingleTon(){

//实例化放在静态代码块里可提高程序的执行效率，但也可能更占用空间

privatefinalstaticSingleToninstance=newSingleTon();

publicstaticSingleTongetInstance(){

returninstance;

第二种：饥汉模式

privateSingleTon(){}

privatestaticinstance=null;//newSingleTon();

publicstaticsynchronizedSingleTongetInstance(){

if(instance==null)

instance=newSingleTon();

第三种：用枚举

publicenumSingleTon{

ONE;

第三：更实际的应用（在什么情况用单例）

publicclassSequenceGenerator{

//下面是该类自身的业务功能代码

privateintcount=0;

publicsynchronizedintgetSequence(){

++count;

//下面是把该类变成单例的代码

privateSequenceGenerator(){}

privatefinalstaticinstance=newSequenceGenerator();

第四：

publicclassMemoryDao

privateHashMapmap=newHashMap();

publicvoidadd(Studentstu1){

map.put(SequenceGenerator.getInstance().getSequence(),stu1);

//把MemoryDao变成单例

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式:定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

publicclassSingleton{

privateSingleton(){}

//在自己内部定义自己一个实例，是不是很奇怪？

//注意这是private只供内部调用

privatestaticSingletoninstance=newSingleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问

publicstaticSingletongetInstance(){

第二种形式:

privatestaticSingletoninstance=null;

publicstaticsynchronizedSingletongetInstance(){

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

instance＝newSingleton();

其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

例：n=1237则输出为：1237，2474，4948，9896，9896，4948，2474，1237，

提示：写程序时，先致谢按递增方式的代码，写好递增的以后，再增加考虑递减部分。

publicstaticvoiddoubleNum(intn)

System.out.println(n);

if(n<=5000)

doubleNum(n*2);

Gaibaota(N)=Gaibaota(N-1)+n

packagecn.demo;

importjava.util.Date;

publicclassA1{

System.out.println(computeAge(8));

publicstaticintcomputeAge(intn)

if(n==1)return10;

returncomputeAge(n-1)+2;

publicstaticvoidtoBinary(intn,StringBufferresult)

if(n/2!=0)

toBinary(n/2,result);

result.append(n%2);

交换式排序、选择排序、插入排序、希尔排序、快速排序

publicclassQuickSort{/***快速排序*@paramstrDate*@paramleft*@paramright*/publicvoidquickSort(String[]strDate,intleft,intright){Stringmiddle,tempDate;inti,j;i=left;j=right;middle=strDate[(i+j)/2];do{while(strDate[i].compareTo(middle)<0&&i0&&j>left)j--;//找出右边比中间值小的数if(i<=j){//将左边大的数和右边小的数进行替换tempDate=strDate[i];strDate[i]=strDate[j];strDate[j]=tempDate;i++;j--;}}while(i<=j);//当两者交错时停止if(ileft){quickSort(strDate,left,j);}}/***@paramargs*/publicstaticvoidmain(String[]args){String[]strVoid=newString[]{"11","66","22","0","55","22","0","32"};QuickSortsort=newQuickSort();sort.quickSort(strVoid,0,strVoid.length-1);for(inti=0;i

//用下面的也可以

//for(inti=0,intj=a.length-1;i

importjava.util.Arrays;

publicclassSwapDemo{

int[]a=newint[]{

(int)(Math.random()*1000),

(int)(Math.random()*1000)

};

System.out.println(a);

System.out.println(Arrays.toString(a));

swap(a);

publicstaticvoidswap(inta[]){

for(inti=0;i

inttmp=a[i];

a[i]=a[len-1-i];

a[len-1-i]=tmp;

/***//***将某个日期以固定格式转化成字符串*@paramdate*@returnstr*/publicStringdate2FormatStr(Datedate){SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss");Stringstr=sdf.format(date);returnstr;}

去零的代码：

returnsb.reverse().toString().replaceAll("零[拾佰仟]","零").replaceAll("零+万","万").replaceAll("零+元","元").replaceAll("零+","零");

publicclassRenMingBi{

*@paramargsaddbyzxx,Nov29,2008

privatestaticfinalchar[]data=newchar[]{

'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'

privatestaticfinalchar[]units=newchar[]{

'元','拾','佰','仟','万','拾','佰','仟','亿'

convert(135689123));

publicstaticStringconvert(intmoney)

StringBuffersbf=newStringBuffer();

intunit=0;

while(money!=0)

sbf.insert(0,units[unit++]);

intnumber=money%10;

sbf.insert(0,data[number]);

money/=10;

returnsbf.toString();

/***//**

*判断任意一个整数是否素数

*@paramnum

*@returnboolean

publicbooleanisPrimeNumber(intnum)

for(inti=2;i<=Math.sqrt(num);i++){

if(num%i==0)

staticint[]bits=newint[]{1,2,3,4,5};

sort("",bits);

privatestaticvoidsort(Stringprefix,int[]a){

if(a.length==1){

System.out.println(prefix+a[0]);

for(inti=0;i

sort(prefix+a[i],copy(a,i));

privatestaticint[]copy(int[]a,intindex){

int[]b=newint[a.length-1];

System.arraycopy(a,0,b,0,index);

System.arraycopy(a,index+1,b,index,a.length-index-1);

returnb;

13+1=2

23+1=9

32+1=28

43+1=65

所以继续的话应是

53+1=126

publicListfind(){

for(inti=1;i<=1000;i++){

if(i%3==0&&i%2!=0){

returnlist;

//返回文件大小privatevoidgetFileSize()throwsRuntimeException,IOException

{//初始化文件大小为0；

this.longSize=0;

//如果文件存在而且是文件，直接返回文件大小

if(file.exists()&&file.isFile()){

this.longSize=file.length();

//文件存在而且是目录，递归遍历文件目录计算文件大小elseif(file.exists()&&file.isDirectory()){

getFileSize(file);//递归遍历

thrownewRuntimeException("指定文件不存在");

publicListqub(Listlist){

Listalist=newArrayList();

Stringa=(String)list.get(i);

if(!a.equals("b")){

alist.add(a);

returnalist;

packagecom;

importjava.io.*;

importjava.util.*;

Vectorv=newVector();

intindex=-1;

booleanisput=false;

publicsynchronizedvoidput(Stringname)throwsInterruptedException{

if(isput){

wait();

v.add(name);

isput=true;

notify();

System.out.println(Thread.currentThread().getName());

publicsynchronizedvoidget()throwsInterruptedException{

if(!isput){

System.out.println(Thread.currentThread().getName()+"取:"+v.get(index));

isput=false;

publicstaticvoidmain(String[]args)throwsCloneNotSupportedException,FileNotFoundException,IOException,InterruptedException{

Test1t=newTest1();

Aa=newA(t);

Bb=newB(t);

newThread(a).start();

newThread(b).start();

classAimplementsRunnable{

Test1t;

publicA(Test1t){

this.t=t;

inti=0;

while(true){

if(i==0){

t.put("男");

t.put("女");

i=(i+1)%2;

classBimplementsRunnable{

publicB(Test1t){

t.get();

importjava.util.ArrayList;

importjava.util.List;

publicclassMaxNum{

publicListMaxs(inta){//先找出能被第一个数整除的数

for(inti=1;i<=a;i++){

if(a%i==0){

publicvoidTest(inta,intb){

Listlist=newMaxNum().Maxs(a);

intbb=(Integer)list.get(i);

if(b%bb==0){//找出能被第二个数整出并且也能被第二个数整除的数

num=bb;

System.out.println("最大公约数为："+num);

newMaxNum().Test(100,1000);

StringBufferstringBuffer=

newStringBuffer().append("abc").reverse();

System.out.println(stringBuffer.toString());

packagecom.tarena;

publicclassNumberSplitChar{

char[]beforechars=str.toCharArray();

char[]afterchars=newchar[beforechars.length];

intj=0;

for(inti=0;i

if(beforechars[i]>=’0′&&beforechars[i]<=’9′){

afterchars[j++]=beforechars[i];

Arrays.sort(afterchars);

for(inti=(afterchars.length-j);i

System.out.print(afterchars[i]);

简单：Number，Boolean，String，Null，Undefined

复合：Object，Array，Function

JSON:(javaScriptObjectNotation)是一种轻量级的数据交换格式。

JSON两种结构：

名称/值对的集合，不同的语言中，它被理解为对象，记录，结构，字典，哈希表，有键列表，关联数组。

值的有序列表，数组

jQuery:

jQuery由美国人JohnResig创建是一个优秀的javascript框架使用户能够方便的处理HTMLdocumentsevents实现动画效果，并且方便地为网站提供AJAX交互。

$(‘foo’).att(‘attr’).val()

可以通过jQuery提供的元素选择器或ID选择器为实现，如：

$(‘div’).append(‘Hello’);要求只能有一个div否则$(‘div’)返回的是数组

$(‘#ID名称’).append(“hello”);

在项目中是怎么用的是看看你有没有项目经验(根据自己的实际情况来回答)你用过的选择器啊，复选框啊，表单啊，ajax啊，事件等。配置Jquery环境下载jquery类库在jsp页面引用jquery类库即可

接下来通过在

答：因为jQuery是轻量级的框架，大小不到30kb,它有强大的选择器，出色的DOM操作的封装，有可靠的事件处理机制(jQuery在处理事件绑定的时候相当的可靠)，完善的ajax(它的ajax封装的非常的好，不需要考虑复杂浏览器的兼容性和XMLHttpRequest对象的创建和使用的问题。)出色的浏览器的兼容性。而且支持链式操作，隐式迭代。行为层和结构层的分离，还支持丰富的插件，jquery的文档也非常的丰富。

1>如果其他库在jquery库之前导入的话

2>如果jquery库在其他库之前导入就直接使用jquery今天在处理一个数据问题时，发现jQuery.ajax()方法返回的值一直有问题，清除缓存后数据无误，多次测试后发现返回的值都是之前的值，并且一直未执行url(后台为JAVA，设置断点一直未进入)。在网上查找下,发现是未设置type的原因。如果没设置jQuery.ajax的type="Post"，那么ajax就会默认type="Get"，这就会导致之前数据被缓存起来。加上type="Post"，问题解决！

jQuery中的选择器大致分为:基本选择器，层次选择器，过滤选择器，表单选择器

jQuery选择器支持CSS里的选择器，jQuery选择器可用来添加样式和添加相应的行为CSS中的选择器是只能添加相应的样式

简单的写法$('ID')来代替document.getElementById()函数支持CSS1到CSS3选择器完善的处理机制(就算写错了id也不会报错)

答：jquery转DOM对象:jQuery对象是一个数组对象，可以通过[index]的丰富得到相应的DOM对象还可以通过get[index]去得到相应的DOM对象。DOM对象转jQuery对象:$(DOM对象)

如果是一些常规的ajax程序的话，使用load(),$.get(),$.post(),就可以搞定了，一般我会使用的是$.post()方法。如果需要设定beforeSend(提交前回调函数),error(失败后处理),success(成功后处理)及complete(请求完成后处理)回调函数等，这个时候我会使用$.ajax()

答:好用的。因为jQuery提供了一些日常开发中夙瑶的快捷操作，例load，ajax，get，post等等，所以使用jQuery开发ajax将变得极其简单，我们就可以集中精力在业务和用户的体验上，不需要去理会那些繁琐的XMLHttpRequest对象了。

答：load方法一般在载入远程HTML代码并插入到DOM中的时候用通常用来从Web服务器上获取静态的数据文件。

如果要传递参数的话，可以使用$.get()或$.post()

addClass()来追加样式

removeClass()来删除样式

toggle()来切换样式

答:首先去装载文档，在页面家在完毕后，浏览器会通过javascript为DOM元素添加事件。

答:使用过。hide()和show()同时修改多个样式属性。像高度，宽度，不透明度。fadeIn()和fadeOut()fadeTo()只改变不透明度slideUp()和slideDown()slideToggle()只改变高度animate()属于自定义动画的方法。

答:一般我会使用的是$.post()方法。如果需要设定beforeSend(提交前回调函数),error(失败后处理),success(成功后处理)及complete(请求完成后处理)回调函数等，这个时候我会使用$.ajax()

答:四种行内式，内嵌式，导入式，链接式

答:append(),appendTo(),prepend(),prependTo(),after(),insertAfter()before(),insertBefore()大致可以分为内部追加和外部追加

append()表式向每个元素内部追加内容。

appendTo()表示讲所有的元素追加到指定的元素中。例$(A)appendTo(B)是将A追加到B中下面的方法解释类似

jQuery中可以用attr()方法来获取和设置元素属性

removeAttr()方法来删除元素属性

html()方法类似于innerHTML属性可以用来读取或者设置某个元素中的HTML内容注意：html()可以用于xhtml文档不能用于xml文档

text()类似于innerText属性可以用来读取或设置某个元素中文本内容。

val()可以用来设置和获取元素的值

答:子代元素是找子节点下的所有元素,后代元素是找子节点或子节点的子节点中的元素

答:使用过，在$.getJSON()方法的时候就是。因为$.getJSON()就是用于加载JSON文件的

答：addClass()方法，attr()方法

答:两个方法有相似的功能，但是在实行时机方面是有区别的。

答：要处理缓存就是禁用缓存.

1$("#msg").text()是返回id为msg的元素节点的文本内容

2$("#msg").text("newcontent");是将“newcontent”作为普通文本串写入id为msg的元素节点内容中,页面显示粗体的newcontent

答:$('input[name=items]').get(1).checked=true;

答：在网页中每个id名称只能用一次，class可以允许重复使用

答:HTML格式,JSON格式,javascript格式,XML格式

三种，html拼接的，json数组，form表单经serialize()序列化的。

hover()和toggle()都是jQuery中两个合成事件。hover()方法用于模拟光标悬停事件。toggle()方法是连续点击事件。

更好的控制页面布局

DIV(division)是一个块级元素，可以包含段落、标题、表格，乃至诸如章节、摘要和备注等。而SPAN是行内元素，SPAN的前后是不会换行的，它没有结构的意义，纯粹是应用样式，当其他行内元素都不合适时，可以使用SPAN在HTML视图中工作时，可以在