java基础题

20100414更新

一、从´a´到´z´字母，随机取10个不能相同的字母,然后对这10个字母按从小到大的方式排序。打印出排序前的字母序列与排序后的字母序列。

实现思路1：

1.   实例一个HashMap对象；

2.   实例一个ArrayList对象；

3.   调用随机函数*26+‘a’产生字母；

4.   for循环10次；

5.   循环体内调用判断map是否有重复key,若存在则i--；否则将结果添加到map及list中；

6.   利用Collections.sort(list)方法从小到大的方式排序

7.   最后输出list中10个从小到大排序不同的字母；

// 方法1

       HashMap map = new HashMap();

       List list = new ArrayList();

       for (int i = 0; i < 10; i++) {

           char c = (char) (Math.random() * 26 + 'a');

           if (map.containsKey(c)) {

              i--;

           }

           map.put(c, c);

           list.add(c);

       }

       Collections.sort(list);

       for (int i = 0; i < list.size(); i++) {

           System.out.print(list.get(i));

       }

      

实现思路2：

1.   实例一个HashSet对象；

2.   调用随机函数*26+‘a’产生字母；

3.   for循环10次；

4.   循环体内调用判断set是否有重复,若存在则i--；否则将结果添加到set中；

5.   利用TreeSet comparator()方法从小到大的方式排序

6.   最后输出list中10个从小到大排序不同的字母；



       //方法2

       HashSet set=new HashSet();

       for (int i = 0; i < 10; i++) {

           char c = (char) (Math.random() * 26 + 'a');

           if (set.contains(c)) {

              i--;

           }

           set.add(c);

       }

       SortedSet ss= new TreeSet(set);    

        ss.comparator();    

        System.err.println(ss);

方法三：

实现思路：

1.         生成26个字母存入与数组中；

2.         随机产生10个数字，并以数字为数组下标取10个字母；

3.         调用Arrays.sort(cha)排序；



public static void getChar(int count) {

              char[] allChar = new char[26];

              for (int i = 97; i < 123; i++) {

                     allChar[i - 97] = (char) i;

              }

              String s = "";

              while (count > 0) {

                     double numDouble = Math.random() * 26;

                     int position = (int) numDouble / 1;

                     String str = String.valueOf(allChar[position]);

            if(s.indexOf(str)!=-1)

                continue;

            s+=str;

                     count--;

              }

              System.out.println(s);

              System.out.println(sortNum(s));

       }



      

   public static String sortNum(String str){

          char[] cha = str.toCharArray();

       Arrays.sort(cha);

       return new String(cha);

   }



20100416更新

1：HttpServletRequest的getParameter和getAttribute方法有什么区别？
　　request.getParameter()方法传递的数据，会从Web客户端传到Web服务器端，代表HTTP请求数据。request.getParameter()方法返回String类型的数据。

        request.setAttribute()和getAttribute()方法传递的数据只会存在于Web容器内部，在具有转发关系的Web组件之间共享。这两个方法能够设置Object类型的共享数据。

        request.getParameter()取得是通过容器的实现来取得通过类似post，get等方式传入的数据。        request.setAttribute()和getAttribute()只是在web容器内部流转，仅仅是请求处理阶段。
       getAttribute是返回对象,getParameter返回字符串

        总的来说：request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的数据。

2：一般Singleton模式通常有几种形式
public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
if (instance==null)
instance＝new Singleton();
return instance; }
}
使用Singleton.getInstance()可以访问单态类。
上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。
注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。
3.在数据库中条件查询速度很慢的时候,如何优化?
a.建索引
b.减少表之间的关联
c.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引（具体怎么优化有专门的文章介绍）
d.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据

4.在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?
解决方案一，按照Object[]数据取出数据，然后自己组bean
解决方案二，对每个表的bean写构造函数，比如表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，然后在hql里面就可以直接生成这个bean了。具体怎么用请看相关文档，我说的不是很清楚。

5:Hibernate session接口的get和load方法有何异同？
当出现异常时get（）返回NULL,而load（）则会抛出异常．

6：spring里面事务的传播属性和事务隔离级别是怎么回事？
Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。 我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。 Spring在TransactionDefinition接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是spring事务管理的核心接口。 getTimeout()方法，它返回事务必须在多少秒内完成。 isReadOnly(),事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。 getIsolationLevel()方法返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。 在TransactionDefinition接口中定义了五个不同的事务隔离级别ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对象 ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。 例如: Mary的原工资为1000,财务人员将Mary的工资改为了8000，但未提交事务 与此同时，Mary正在读取自己的工资 Mary发现自己的工资变为了8000，欢天喜地！ 而财务发现操作有误，而回滚了事务,Mary的工资又变为了1000. 像这样,Mary记取的工资数8000是一个脏数据。
1: 保证一个事务修改的数据提交后才能被另外一个事务读取。
ISOLATION_READ_COMMITTED 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。 ISOLATION_REPEATABLE_READ 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。 在事务1中，Mary 读取了自己的工资为1000,操作并没有完成 在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务. 在事务1中，Mary 再次读取自己的工资时，工资变为了2000 在一个事务中前后两次读取的结果并不致，导致了不可重复读。 使用ISOLATION_REPEATABLE_READ可以避免这种情况发生。 ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。 目前工资为1000的员工有10人。 事务1,读取所有工资为1000的员工。 共读取10条记录 这时另一个事务向employee表插入了一条员工记录，工资也为1000 事务1再次读取所有工资为1000的员工 共读取到了11条记录，这就产生了幻像读。 ISOLATION_SERIALIZABLE能避免这样的情况发生。但是这样也耗费了最大的资源。 getPropagationBehavior()返回事务的传播行为，由是否有一个活动的事务来决定一个事务调用。 在TransactionDefinition接口中定义了七个事务传播行为。
2: 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。
PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 使用spring声明式事务，spring使用AOP来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。 单独调用methodB方法 相当于 Spring保证在methodB方法中所有的调用都获得到一个相同的连接。在调用methodB时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。 单独调用MethodA时，在MethodA内又会调用MethodB. 执行效果相当于 调用MethodA时，环境中没有事务，所以开启一个新的事务. 当在MethodA中调用MethodB时，环境中已经有了一个事务，所以methodB就加入当前事务。
3:如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。
PROPAGATION_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。 单纯的调用methodB时，methodB方法是非事务的执行的。 当调用methdA时,methodB则加入了methodA的事务中,事务地执行。 PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。 当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常 throw new IllegalTransactionStateException("Transaction propagation ''mandatory'' but no existing transaction found"); 当调用methodA时，methodB则加入到methodA的事务中，事务地执行。
4: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。 当单独调用methodB时，相当于把methodb声明为REQUIRED。开启一个新的事务，事务地执行。 当调用methodA时 情况有些大不一样.相当于下面的效果。 在这里，我把ts1称为外层事务，ts2称为内层事务。从上面的代码可以看出，ts2与ts1是两个独立的事务，互不相干。Ts2是否成功并不依赖于ts1。如果methodA方法在调用methodB方法后的doSomeThingB方法失败了，而methodB方法所做的结果依然被提交。而除了methodB之外的其它代码导致的结果却被回滚了。 使用PROPAGATION_REQUIRES_NEW,需要使用JtaTransactionManager作为事务管理器。

5:总是非事务地执行，并挂起任何存在的事务。
PROPAGATION_NOT_SUPPORTED 总是非事务地执行，并挂起任何存在的事务。 当单独调用methodB时，不启用任何事务机制，非事务地执行。 当调用methodA时，相当于下面的效果 使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。

6:总是非事务地执行，如果存在一个活动事务，则抛出异常 单独调用methodB，则非事务的执行。
PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常 单独调用methodB，则非事务的执行。 调用methodA则会抛出异常

7:
PROPAGATION_NESTED如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行 这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。需要JDBC 驱动的java.sql.Savepoint类。有一些JTA的事务管理器实现可能也提供了同样的功能。 使用PROPAGATION_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true; 而nestedTransactionAllowed属性值默认为false; 如果单独调用methodB方法，则按REQUIRED属性执行。 如果调用methodA方法，相当于下面的效果 当methodB方法调用之前，调用setSavepoint方法，保存当前的状态到savepoint。如果methodB方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB()方法)调用失败，则回滚包括methodB方法的所有操作。 嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。 PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别:它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务这是一个真正的嵌套事务。同时它需要JTA事务管理器的支持。 使用PROPAGATION_NESTED时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。DataSourceTransactionManager使用savepoint支持PROPAGATION_NESTED时，需要JDBC 3.0以上驱动及1.4以上的JDK版本支持。其它的JTA TrasactionManager实现可能有不同的支持方式。 PROPAGATION_REQUIRED应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

7：什么是线程安全？
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

synchronize 修饰定义一个对象或者方法或者属性的访问必须串行化访问，顾名思义像在银行取钱要排队一样，那个业务员就是一个synchronize 对象。只有像我等无钱之辈才去排队，那些个VIP自然不用了。

　wait 和notify notifyAll是一家的，他们是对象级的锁，余天生驽钝，这个偶翻了许多资料才理解，如果不能理解就看代码吧。多线程中的一个去访问共享资源发现有人使用，于是就在这个资源上面wait，占用者如果使用完了就notify（）一下通知下一个等待者可以进来了，notifyAll（）就是说在外面等的一起上吧！可是只能服务与一个人，于是大家抢着进去，力气大的自然占便宜。可是在java世界里面JVM说了算。 有wait和notify的地方一定有synchronize，反过来不成立，wait 和notify不在Thread的势力范围。

8：checkexception和runtimeexception区别？
Java异常分为两大类:checked 异常和unChecked 异常。所有继承java.lang.Exception 的异常都属于checked异常。所有继承java.lang.RuntimeException的异常都属于unChecked异常。
当一个方法去调用一个可能抛出checked异常的方法，必须通过try…catch块对异常进行捕获进行处理或者重新抛出。
我们看看Connection接口的createStatement()方法的声明。
一个是子类，一个是父类.
RuntimeException也不应该去捕获，因为这类的Exception都是不可恢复的，而且往往是因为程序的BUG才会导致这类Exception，比如说NullPoint，或者IndexOutOfBound等等。捕获这类Exception事实上是在隐藏错误。