提供一些面试题

以下是个人总结及朋友总结的，大家有更好的答案欢迎讨论。
1.打印九九乘法表public static void cfb(int m) {
 
for (int i = 1; i < m; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + i * j + "  ");
}
System.out.println();
}
  } public static void nineNineMulitTable(int m) {
   
for (int i = 1, j = 1; j <= m; i++) {
System.out.print(i + "*" + j + "=" + i * j + " ");
if (i == j) {
i = 0;
j++;
System.out.println();
}
}
 
}2.求第一大数、第二大数的序号
public class FirstSecond { public static void main(String[] args) { // 取出输入的数字并转换成String数组
System.out.print("Please input numbers:");
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
String[] arg = s.split(","); // String数组转换为int类型数组
int[] arrays = new int[arg.length];
for (int i = 0; i < arg.length; i++) {
arrays[i] = Integer.parseInt(arg[i]);
}
// firstSecond(arrays);
sort(arrays); } // 先找出第一大值，再遍历数组找到小于第一大值的最大值
public static void firstSecond(int[] array) {
int tempFirst = 0, first = 0;
int tempSecond = 0, second = 0; for (int i = 0; i < array.length; i++) {
if (first < array[i]) {
first = array[i];
tempFirst = i;
}
} for (int i = 0; i < array.length; i++) {
if ((second < array[i]) && (array[i] != first)) {
second = array[i];
tempSecond = i;
}
} System.out.println("The serial number is:" + tempFirst + "  "
+ tempSecond); } // 先将数组排序
public static void sort(int[] array) { int[] arrayClone = (int[]) array.clone();
int length = array.length - 1;
int tempSecond = 0, tempFirst = 0; for (int i = length; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (array[j] > array[i]) {
int temp = array[j];
array[j] = array[i];
array[i] = temp;
 
}
}
}
 for (int i = 0; i < array.length; i++) {
 System.out.print(array[i]+" ");
 } for (int i = 0; i <= length; i++) {
if (arrayClone[i] == array[length]) {
tempFirst = i;
}
if (arrayClone[i] == array[length - 1]) {
tempSecond = i;
}
}
System.out.println("The serial number is:" + tempFirst + " "
+ tempSecond); }
}

解决方案 »

  1.   

    3.求字符串中出现最小次数的字母及字母出现的次数public class LeastChar { /**
     * 求字符串中出现最小次数的字母及字母出现的次数
     */
    public static void main(String[] args) {
    System.out.print("Please input string:");
    Scanner sc = new Scanner(System.in);
    String s = sc.nextLine();
    leastChar(s); }  
    public static void leastChar(String str) {
    int leastCount = 0;  Map<Character, Integer> map = new HashMap<Character, Integer>();
    char[] ch = str.toCharArray(); for (int i = 0; i < ch.length; i++) {

    Integer in = map.get(ch[i]);
    map.put(ch[i], in == null ? 1 : ++in); }
    Set<Character> minSet = new HashSet<Character>();
    leastCount = Collections.min(map.values());


    Iterator iterator = map.keySet().iterator();
    while(iterator.hasNext()){
    Character c = (Character)iterator.next();
    int i = map.get(c);
    if(i==leastCount)  minSet.add(c);

    } 
    System.out.println("The least char is:" + minSet + "  " + leastCount);
     
    }  
    }
    4.打印1/阶层，并保留两位小数public class RecursionFactorial {
    public static void main(String[] args) {
    long result = 1;
    result = recur(3);
    System.out.println(result); 
    System.out.println(round(result));
    } public static long recur(int n) {
    if (n == 1)
    return 1;
    else
    return n * recur(n - 1);
    }
    public static double round(double n) {  
    n = Math.round(1/n*100); 
    n = n/100;   
    return n;
    }
     
    }
      

  2.   

    4.打印1/阶层，并保留两位小数
    有个笔误：long result = 1; result = recur(3);改为long result = recur(3);
     
      

  3.   

    5.两个对象值相同(x.equals(y) == true)，一定有相同的hash code吗
    在JDK的规范中，A.equals(B) 一定可以推出A.hashCode() == B.hashCode(); 反之则不一定成立。当然，你在自己的类中可以不符合上述规范。是允许的，但是不推荐的。
    6.>> >>>的区别
     >>>是无符号右移，用0来填充
     >>是有符号右移，负数用1来填充，正数用0来填充
    7.io nio的区别
    传统的阻塞式IO，每个连接必须要开一个线程来处理，并且没处理完线程不能退出。 
    非阻塞式IO，由于基于反应器模式，用于事件多路分离和分派的体系结构模式，所以
    可以利用线程池来处理。事件来了就处理，处理完了就把线程归还。而传统阻塞方式不能使用线程池来处理，假设当前有10000个连接，非阻塞方式可能用1000个线程的线程池就搞定了，而传统阻塞方式就需要开10000个来处理。如果连接数较多将会出现资源不足的情况。非阻塞的核心优势就在这里。
    （这个问题我也不太了解，有熟悉的可以用简单的语言帮忙概括一下）
    8.单例模式public class Singleton {
    private static Singleton instance = null;
    private Singleton() {
    }
    public static Singleton getInstance() {
    if (instance == null) {
    instance = new Singleton();
    }
    return instance;
    } 
    }9.如果其中的元素有序，选择Set的哪个子类，里面的元素应该具有什么样的特性（题目记不太清楚了大概是这样）
    TreeSet  ,其中的元素不能相互equals（不太确定，有熟悉的可以帮忙说一下）
    10.数组引用public class ArrayRef {  
    public static void main(String[] args) {
       int[] array ={0,1,2};
       int[] array2 = array.clone();
       int[] array3 = array;
       array3[2]=10;
       array2[2]=20;
       System.out.println(array[2]);
       System.out.println(array2[2]);
       System.out.println(array3[2]);
    }
    }结果是：10
           20
           10
      

  4.   

    Struts1和Struts2 的区别
    Struts1要求Action 类继承一个抽象基类。Struts1 的一个普遍问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action 接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport 基类去 实现 常用的接口。Action 接口不是必须的，任何有execute 标识的POJO 对象都可以用作Struts2的Action对象。 
    线程模式: Struts1 Action 是单例模式并且必须是线程安全的，因为仅有Action 的一个实例来处理所有的请求。单例策略限制了Struts1 Action 能作的事，并且要在开发时特别小心。Action 资源必须是线程安全的或同步的。 Struts2 Action 对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet 容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题） 
    Servlet 依赖: Struts1 Action 依赖于 Servlet API ,因为当一个 Action 被调用时 HttpServletRequest 和 HttpServletResponse 被传递给execute 方法。Struts 2 Action 不依赖于容器，允许Action 脱离容器单独被测试。如果需要，Struts2 Action 仍然可以访问初始的 request 和 response。但是，其他的元素减少或者消除了直接访问 HttpServetRequest 和 HttpServletResponse 的必要性。 
    可测性:测试Struts1 Action 的一个主要问题是execute 方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1 的模拟对象（来进行测试）。Struts 2 Action 可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。 
    捕获输入:  Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他 JavaBean 不能用作ActionForm，开发者经常创建多余的类捕获输入。动态Bean （DynaBeans）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存在的 JavaBean（仍然会导致有冗余的javabean）。  Struts 2 直接使用Action 属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich 对象类型。Action 属性能够通过 web 页面上的taglibs 访问。 Struts2 也支持ActionForm模式。rich 对象类型，包括业务对象，能够用作输入/输出对象。这种 ModelDriven 特性简化了taglib 对POJO 输入对象的引用。
     表达式语言：Struts1 整合了JSTL，因此使用JSTL EL。这种EL 有基本对象图遍历，但是对集合和索引属性的支持很弱。  Struts2 可以使用 JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL). 
    绑定值到页面（view）:  Struts 1 使用标准JSP 机制把对象绑定到页面中来访问。  Struts 2 使用 "ValueStack"技术，使taglib 能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack 策略允许通过一系列名称相同但类型不同的属性重用页面（view）。 
    类型转换：Struts 1 ActionForm 属性通常都是String 类型。Struts1 使用Commons-Beanutils 进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。  Struts2 使用OGNL 进行类型转换。提供基本和常用对象的转换器。
     校验：Struts 1 支持在ActionForm的validate 方法中手动校验，或者通过Commons Validator 的扩展来校验。同一个类可以有不同的校验内容，但不能校验子对象。  Struts2 支持通过validate 方法和XWork 校验框架来进行校验。XWork 校验框架使用为属性类类型定义的校验和内容校验，来支持chain 校验子属性 
    Action 执行的控制：  Struts1 支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action 必须共享相同的生命周期。Struts2 支持通过拦截器堆栈（Interceptor Stacks）为每一个Action 创建不同的生命周期。堆栈能够根据需要和不同的Action 一起使用。
    truncate和delete区别
     truncate和delete有以下几点区别：1、truncate在各种表上无论是大的还是小的都非常快。如果有ROLLBACK命令delete将被撤销，而truncate则不会被撤销。2、truncate是一个DDL语言，象其他所有的DDL语言一样，将被隐式提交，不能对truncate使用ROLLBACK命令。3、truncate将重新设置高水平线和所有的索引。在对整个表和索引进行完全浏览时，经过truncate操作后的表比delete操作后的表要快得多。4、truncate不能触发任何delete触发器。5、不能授予任何人清空他人的表的权限。6、当表被清空后表和表的索引将重新设置成初始大小，而delete则不能。  7、不能清空父表。 truncate TABLE (schema)table_name DROP(REUSE) STORAGE 在默认是 DROP STORAGE 当使用DROP STORAGE时将缩短表和表索引，将表收缩到最小范围，并重新设置NEXT参数。REUSE STORAGE不会缩短表或者调整NEXT参数在特殊情况下使用 REUSE ST。