• 25匹马的问题
  

25匹马  5个跑道，每次只能跑5匹，用最少的次数选出最快的前3匹
7次．前5轮是每队各比一场，假设排名如下：
A1 A2 A3 A4 A5
B1 B2 B3 B4 B5
C1 C2 C3 C4 C5
D1 D2 D3 D4 D5
E1 E2 E3 E4 E5
A1,B1,C1,D1, E1比第6场，假设 A1>B1>C1>D1>E1淘汰一些马,如下: A1 A2 A3 A4 A5B1 B2 B3 B4 C1 C2 C3D1 D2E1第七场可以在 A2 A3 B1 B2 C1中赛出第2和第3.                                                                       

• JDK1.5泛型实现原理
  实际是通过编绎前处理，或者编译器实现的
  

• Spring-AOP: JDK代理和CGLIB代理的区别
• synchronized关键字的理解 线程同步：     
  
          由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
  
  需要明确的几个问题：
  
         1)synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
          2)无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
          3)每个对象只有一个锁（lock）与之相关联。
          4)实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
  
  1、synchronized关键字的作用域有二种：
  
          1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
  
          2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
  
          synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
  　　
  　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
  　　
  　　synchronized 方法的缺陷：同步方法，这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象 P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法.同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（;若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
  
  2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this) {/*区块*/}，它的作用域是当前对象。
  
          这时锁就是对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：
  class Foo implements Runnable
  {
         private byte[] lock = new byte[0]; // 特殊的 instance变量
      Public void methodA()
  {
         synchronized(lock) { //… }
  }
  //…..
  }
  注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而 Object lock = new Object()则需要7行操作码。
  
  3．将synchronized作用于static 函数，示例代码如下：
        Class Foo
  {
  public synchronized static void methodAAA()   // 同步的static 函数
  {
  //….
  }
  public void methodBBB()
  {
         synchronized(Foo.class)   // class literal(类名称字面常量)
  }    }
         代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
  
  可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。B方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。
  
  对共享资源的同步访问更加安全的技巧：
  
  
          1） 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。
          2）如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。
  
  补充：
  
  synchronized 关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。
  

• list map set 区别
  Collection：List、Set
  Map：HashMap、HashTable
  如何在它们之间选择
  
  一、Array ， Arrays
  Java所有“存储及随机访问一连串对象”的做法，array是最有效率的一种。
  1、
  效率高，但容量固定且无法动态改变。
  array还有一个缺点是，无法判断其中实际存有多少元素，length只是告诉我们array的容量。
  2、Java中有一个Arrays类，专门用来操作array。
      arrays中拥有一组static函数，
  equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
  fill()：将值填入array中。
  sort()：用来对array进行排序。
  binarySearch()：在排好序的array中寻找元素。
  System.arraycopy()：array的复制。
  
  二、Collection ， Map
  若撰写程序时不知道究竟需要多少对象，需要在空间不足时自动扩增容量，则需要使用容器类库，array不适用。
  1、Collection 和 Map 的区别
  容器内每个为之所存储的元素个数不同。
  Collection类型者，每个位置只有一个元素。
  Map类型者，持有 key-value pair，像个小型数据库。
  2、各自旗下的子类关系
  Collection
      --List： 将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。
            --ArrayList / LinkedList / Vector
      --Set ： 不能含有重复的元素
            --HashSet / TreeSet
  Map
      --HashMap
      --HashTable
      --TreeMap
  3、其他特征
  *  List，Set，Map将持有对象一律视为Object型别。
  *  Collection、List、Set、Map都是接口，不能实例化。
     继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class，这些才可被实例化。
  *  vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查。
  
  三、Collections
  Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。
  相当于对Array进行类似操作的类——Arrays。
  如，Collections.max(Collection coll); 取coll中最大的元素。
      Collections.sort(List list); 对list中元素排序
  
  四、如何选择？
  1、容器类和Array的区别、择取
     *  容器类仅能持有对象引用（指向对象的指针），而不是将对象信息copy一份至数列某位置。
     *  一旦将对象置入容器内，便损失了该对象的型别信息。
  2、
    *  在各种Lists中，最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList()；
       Vector总是比ArrayList慢，所以要尽量避免使用。
    *  在各种Sets中，HashSet通常优于HashTree（插入、查找）。只有当需要产生一个经过排序的序列，才用TreeSet。
       HashTree存在的唯一理由：能够维护其内元素的排序状态。
    *  在各种Maps中
       HashMap用于快速查找。
    *  当元素个数固定，用Array，因为Array效率是最高的。
  结论：最常用的是ArrayList，HashSet，HashMap，Array。
  
  注意：
  1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。
  2、Set和Collection拥有一模一样的接口。
  3、List，可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个，get(0)...。(add/get)
  4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。
  5、Map用 put(k,v) / get(k)，还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。
     HashMap会利用对象的hashCode来快速找到key。
      *  hashing
         哈希码就是将对象的信息经过一些转变形成一个独一无二的int值，这个值存储在一个array中。
         我们都知道所有存储结构中，array查找速度是最快的。所以，可以加速查找。
        
         发生碰撞时，让array指向多个values。即，数组每个位置上又生成一个梿表。
  6、Map中元素，可以将key序列、value序列单独抽取出来。
  使用keySet()抽取key序列，将map中的所有keys生成一个Set。
  使用values()抽取value序列，将map中的所有values生成一个Collection。
  为什么一个生成Set，一个生成Collection？那是因为，key总是独一无二的，value允许重复
  
  
  

Vector是线程安全的

栈：存放基本数据类型的数据以及根据类产生的对象的引用变量。
堆：存放的是对象。
用new构造函数产生一个对象后，JVM就将这个对象存放在堆中，为了要操作对象的属性和方法，则必须要在栈中定义一个变量来指向堆中的这个对象，栈中的变量的值是对象在堆中的首地址，栈中的变量称为引用变量。

九亭电脑维修 复印机 打印机维修 监控网络安装 IT外包等
廖工:15901732217