JAVA基础点汇总（四）

   1. ArrayList list = new ArrayList(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象.
   2. 判断一个字符串中出现了几次另一个字符串。
   3. ArrAyList和LinkedList的区别。
   4. xml文件的两种读取方式
   5. 分析下面的程序(内部类、返回值为void能否加return、只有try但是最后要加finally。
   6. 单例模式例子
   7. JAVA定时器
   8. Hibernate的几中懒(延时)加载模式
   9. java无限循环有几种方法

   10. Spring如何管理事务

1. ArrayList list = new ArrayList(); 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
  考点：java反射。一个类可以有很多的对象，但是这个类的Class对象只有一个，只要是这个类里面有的成员，Class对象中也有。
Class对象中的方法或变量都是这个类中的原始成员，没有新增任何限制，如：泛型。
Class clazz = list.getClass();   clazz.getMethods();-->这里得到的方法如add(Object o)，里面就没有限定只能放哪种数据类型，而是可以放任何的数据类型。
public class StringToInteger {


public static void main(String[] args) throws Exception{

List<Integer> list = new ArrayList<Integer>();
Class clazz = list.getClass();
Method methods[] = clazz.getMethods();
for(Method method : methods)
System.out.println(method);
methods[1].invoke(list, "hello");
System.out.println(list.size());
System.out.println(list.get(0));
}
}
打印结果：hello
2. 判断一个字符串中出现了几次另一个字符串。
答：思想：先求出开始那个字符串的长度s1，然后把这个字符串中所有出现的另一个字符串都用""替换掉，然后求出替换后的字符串的长度s2，求出那个要求出现了多少次的那个字符串长度s3，最后用(s1-s2)/s3就是出现的次数了。
          String str1 = "sjhabfabcjabcsabchabcjabc";
String s = "abc";

String str2 = str1.replace("abc", "");
int count = (str1.length()-str2.length())/s.length();
System.out.println("出现了"+count+"次");
3、ArrayList和LinkedList的区别。
答：List集合比Set集合仅仅是多了索引，所以ArrayList和LinkedList都有索引。
    (1). ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 
    (2)．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。
    (3)．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
    (4)．LinkedList不支持高效的随机元素访问get,因为LinkedList要移动指针。 
    (5)．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。
可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
4、xml文件的两种读取方式
   1、DOM(Document Object Model)文档对象模型
   2、SAX(Simple Api For Xml)
   DOM和SAX的区别：
      DOM：
   一次性把xml文件里的内容读取到一个对象中，以后要查看这个xml中的内容，直接从这个对象中读取即可，效率高，不适合读取大文件。
      SAX：
   可以分段读取，需要什么样的内容就从xml里面读取哪一段，效率低，适合读取大文件。
5、分析下面的程序(内部类、返回值为void能否加return、只有try但是最后要加finally)
  public class Foo {
public static void main(String rags[]){
fuo();
fun();
}
public static class Inner{//Inner是一个静态内部类，在其它类中可以通过new Inner()方式创建对象。
public static String str="abc";//在其他类中可以通过Foo.Inner.str方式调用。
}
public static void fun(){
try{
return ; //返回值类型为void，可以有return语句，但是不能返回任何值。
}finally{
System.out.print("fun");//finally语句块最后执行，而且一定会执行。
}
}
public static void fuo(){
try {
throw new Exception();  
//这里抛出了一个异常，当在try语句块中碰到异常的时候吗，流程马上会跳到catch语句块中执行。
} catch (Exception e) {
System.out.println("Exception");
}
}
 }


打印结果：Exception    
         fun   
6、单例模式例子
public class Single {
private String name;
private static Single single = null;


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}

private Single(){} //私有化构造方法，防止在其他类通过构造方法生成对象

public static Single getInstance(){  //提供一个唯一的对象
if(single==null){
single = new Single();
}
return single; 
}
}
测试eg:  public static void main(String args[]){
 Single s1 = Single.getInstance();
 s1.setName("张三");

 Single s2 = Single.getInstance();
 s2.setName("李四");

 System.out.print(s1.getName());
 System.out.print(s2.getName());
 }
打印结果是：李四   李四   因为s1和s2是同一个对象
7、JAVA定时器
答：定时器类Timer , 启动定时器的方法:Timer.schedule(TamerTask, ..., ...);
8、Hibernate的几中懒(延时)加载模式
 答：当访问的数据量比较大时，不适合用Hiibernate缓存，因为利用缓存还要给它分配资源，这样就大大增加了系统的压力，也浪费了大量系统资源。利用懒加载，当数据需要被用到的时候，我们才去查询它，这样就能有效的利用系统资源。
    强制加载的方式有两种：(1). 当用户强制执行发出SQL命令的时候   (2). 碰到initialized时候会去加载
   使用懒加载的情况：(1). <many-to-one> 比如学生和课程，一个学生可以有多个课程，当加载学生的信息的时候，我们并不需要课程信息，这时候使用懒加载，当需要课程信息的时候再去加载。
      (2). <one-to-one>  班级和学生(学生表包含班级ID)，查主表默认使用join连接不会发生懒加载，当查询从表的时候，默认会先查询出从表对象，然后根据从表对象查询主表对象又发出了一次select。
9、java无限循环有几种方法
  (1). for循环   (2). while循环   (3). 线程无限循环   (4). 定时器无限循环
10、Spring如何管理事务
答：Spring有两种事务管理方式，声明式和编程式 ，一般使用声明式。
 (1). 声明式事务管理方式是通过AOP实现的。
 (2). AOP面向切面的编程，它会给我们的目标类生成一个代理类，通过代理类来操作目标类，即在不改变原代码的情况下，对原有的功能进行了扩展。
 在service类前加@Transactional即对这个类的所有方法声明了事务管理，当访问每一个方法时，会先创建打开一个事务，在执行完这个方法后又会根据执行的情况进行提交或者回滚操作。