java基础面试题1

关于switch语句

@Test
public void test08(){
String str = "d";
switch (str) {
case "A":
System.out.println("A");
break;
case "B":
System.out.println("B");
break;
case "C":
System.out.println("C");
break;
//找不到匹配时
default:
System.out.println(0);
}
}

如何将字符串转换为基本数据类型？

@Test
public void de(){
String wee="12";//常用于前台id传递时使用转换
int e=    Integer.parseInt(wee);
System.out.println(e);
}
//数字转字符串:String.valueOf();

如何将基本数据类型转换为字符串？

将基本数据类型+” “字符串即可

动静态代理的区别，什么场景使用？

静态代理通常只代理一个类，

动态代理指代理一个接口下的多个实现类

8种基本数据类型字节数

byte 1 char2 sort2 int4 float4 double8 long 8

Java 中会存在内存泄漏吗，请简单描述

答：理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄露的发生。例如hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露

关于匿名内部类；可以继承其他类或实现其他接口，内部类可以访问外部类的私有属性

final关键字用法：1.不能继承2不能重写3修饰变量（加final变成常量）

String和StringBuilder、StringBuffer的区别

String是只读字符串，而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改，StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer要高。

//用递归实现字符串反转
public static String reverse(String originStr) {
if(originStr == null || originStr.length() <= 1)
return originStr;
return reverse(originStr.substring(1)) + originStr.charAt(0);
}

以下是值传递

public class test {
int i;

/**值传递机制
在汇编上，参数入栈，是 push。这个 push 是把一个整数，
从某一个存储位置（不管该位置位于 CPU 内或外），复制到 stack 顶部。（这里我们不谈语意）。
光看这个本质，你就懂得，参数入栈时，是一个整数，被 copy 了一份，一份是这个整数的来源，  一个是栈上的拷贝.
现在加上语意，如果这个整数是一个 int 变量，我们想要修改这个变量，这个 int 变量被复制了一个副本放在栈上的参数位置了。
你对这个参数的改动，不会影响到这个源。
这就是所谓“为什么值传递，不能修改外部源”这句话在描述的*/

public static void main(String[] args) {
int i=2;
SChange(i+1);
System.out.println(i);
}
public static void SChange (int i) {
i=1;

}
}

Iterator和ListIterator主要区别在以下方面：

1.ListIterator有add()方法，可以向List中添加对象，而Iterator不能

2. ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。

3. ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

4.都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

多线程的创建方式

一种是继承Thread类；另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为，推荐使用后者，因为Java中的继承是单继承，一个类有一个父类，如果继承了Thread类就无法再继承其他类了，显然使用Runnable接口更为灵活。Java 5以后创建线程还有第三种方式：实现Callable接口，该接口中的call方法可以在线程执行结束时产生一个返回值

一般什么情况下会有内存泄露

理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄露的发生。例如hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露

Java内存有哪几块区域，分别对应的作用

java中的内存被分成以下四部分：

①、代码区 ②、栈区 ③、堆区 ④、静态区域

栈区：由编译器自动分配释放，存放函数的值，局部变量的值，具体方法执行结束后，系统自动释放jvm内存资源

堆区：一般由程序员分配释放，存放new分配的对象和数组，JVM不定时查看这个对象，如果没有引用指向这个对象就回收（==String s = new String(“xyz”);创建了几个字符串对象？

答：两个对象，一个是静态区的”xyz”，一个是
4000
用new创建在堆上的对象==）

静态区：存放全局变量、静态变量和字符串常量，不释放

代码区：存放程序中方法的二进制代码，而且是多个对象共享一个代码空间区域

框架相关

项目的高并发访问，如果只是运用synchronizedhashmap，及hashtable在大数量级访问下的效率极低，这时，ConcurrentHashMap允许多个修改操作并发进行

ConcurrentHashMap中主要实体类就是三个：ConcurrentHashMap（整个Hash表）,Segment（桶），HashEntry（节点）

反射中，Class.forName()和ClassLoader.loadClass的区别

object常用方法有哪些

equals()：在object类中，相当于==运算符

hashCode()：返回该对象的哈希码值(整数)，用于标识一个对象，如果两个对象相等，则哈希码值一定相同

toString()：返回值是String类型，描述当前对象的有关信息，当对象与String型数据的连接时，自动调用其toString()方法

联上，为什么要**重写**hashcode， toString 方法？

重写hashcode，保证相同的对象返回相同的hash值，不同的对象返回不同的hash值。重写toString是对对象打印输出的一种格式化。

Servlet是单例的，那如果有一个hashmap或者ArrayList成员属性，怎样解决不安全的问题（final或Threadlocal）

Post和get的区别

1.数据安全

get会被缓存，此其他人可以从浏览器的历史记录中读取到这些数据，例如账号和密码等，post一般没有这种问题

2.数据大小

get方式：对传输的数据大小有限制（通常不能大于2kb）

post方式：传递的数据量要比get方式大的多（理论上不受限制）

3.提交形式

get方式：请求会将参数跟在URL后进行传递，也就是在地址栏提交

post方式：请求是作为http消息的实体内容发送给web服务器，也就是是以数据体的形式提交

windows onload 和jQuery中的ready 区别

以下代码无法正确执行，结果只输出第二个：
window.onload = function(){
alert(“text1”);
};
window.onload = function(){
alert(“text2”);
};
以下代码正确执行：
$(document).ready(function(){
alert(“Hello World”);
});
$(document).ready(function(){
alert(“Hello again”);
});

结果两次都输出

讲一下linux 的常用指令

ls 查看文件夹内部信息

ls -a 查看隐藏文件

ls -l 查看文件的详细信息等于 ll

ls -al 查看隐藏文件以及详细信息

cd 切换目录

mkdir /abc 创建目录递归目录

mkdir -p /test/mydir 建立

touch 创建文件

List集合中的contains（去重）方法

contains方法在执行后首先会调用indexOf()方法。indexOf()方法会判断传入的对象是否为空，如果为空，则遍历整个集合的元素，如果集合的某个元素为空，返回该元素的下标。如果传入对象不为空，则遍历整个集合的元素，如果该元素和集合内某个元素的equals比较结构为true，返回该元素下标。可以看到如果遍历完集合后没有元素存在于集合中就返回-1。最后contains还做了判断，如果indexOf()方法返回大于0，就说明集合内存在该元素，小于0则不存在。

手写单例模式

public class SingletonClass{//懒汉式
private static SingletonClass instance=null;
public static　synchronized　SingletonClass getInstance(){
if(instance==null){
instance=new SingletonClass();
}
return instance;
}
private SingletonClass(){
}
}

public class Singleton{//饿汉式
//在自己内部定义自己的一个实例，只供内部调用
private static final Singleton instance = new Singleton();
private Singleton(){
}
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance(){
return instance;
}
}
//饿汉式双重锁
public class Singleton{
private static volatile Singleton instance=null;
private Singleton(){
//do something
}
public static  Singleton getInstance(){
if(instance==null){
synchronized(SingletonClass.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}
或者是使用了Java的静态内部类，因为SingletonClass没有static的属性，因此并不会被初始化
直到调用getInstance()的时候，会首先加载SingletonClassInstance类，
这个类有一个static的SingletonClass实例，因此需要调用SingletonClass的构造方法，
然后getInstance()将把这个内部类的instance返回给使用者。
由于这个instance是static的，因此并不会构造多次。
由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，
同样，static语义也要求不会有多个实例存在。
并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。
同样，由于这个构造是并发的，所以getInstance()也并不需要加同步。
public class SingletonClass {
private static class SingletonClassInstance {
private static final SingletonClass instance = new SingletonClass();
}
public static SingletonClass getInstance() {
return SingletonClassInstance.instance;
}
private SingletonClass() {
}

}

什么时候使用单例？

1读取配置文件的类用单例，配置文件只要读取一次就可以全局使用了，

没有必要想读取一个属性值时，去创建一个实例重读配置文件的

2数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

3多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

单例模式应用的场景一般发现在以下条件下：

　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。