Java基础知识总结（二）~持续学习中

30.try-catch

 public class Test {  
   
     public static void main(String[] args) {   
         System.out.println("return value of getValue(): " + getValue());   
     }   
   
        public static int getValue() {   
         int i = 1;   
         try {   
                  return i;   
         } finally {   
             System.out.println("i :  finally");  
             ++i;   
         }   
     }   
   
 }

 

public static boolean get() {  
     try {  
            return  false;  
     } finally {  
            return  true;  
     }  
 } 

 在try中的return真正返回之前 ，会将false保存到一个临时变量（假设为var）中 ，然后执行finally，在执行finally子句的任何语句之前，会将var中的值取出，如果finally中没有抛出异常或return、break、continue等语句，则在finally执行完后返回var （相当于返回去完成try中return的执行），如果finally中有return，var值会被覆盖 ，返回结果是finllay子句中 return的值，如果是异常或break、continue等则执行相应的操作而不是返回。更详细解释参考JVM规范或《深入理解JAVA虚拟机（第二版）》。

其实相当于值传递

结果：1    true

 

31、返回一个n位随机数

random.nextInt(n)

返回0~n 间的整数,包括0，不包括n

public static String getRandStr(int n){  
        Random random = new Random();  
        String sRand = "";  
        for (int i = 0; i < n; i++) {  
            String rand = String.valueOf(random.nextInt(10));  
            sRand += rand;  
        }  
        return sRand;   
    } 

 getRandStr(4)可返回一个4为数

32、java中的main方法

String args[]保存的是 JAVA运行时传递给所运行类的参数,你这个类需要参数就传,不需要就不传.

public class TestMain{
    public static void main(String args[]){
        for(int i=0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}

 
接着用java TestMain first second运行
结果:
first
second

 

args实际上是个变量。它用来存储你用命令后执行.class文件时后面跟的参数。args是可以变的，你可以变为你喜欢的任意标识符。
普通方法其实可以不给，只是你在设计方法的时候要给一个不传参数的方法。

 

注意:

1、其返回类型应该为void

2、必须为公共方法

写道

6. 哪一个对单机程序中的main()方法的声明是错误的？（多选）DE

a. public static void main()
b. public static void main(String[] string)
c. public static void main(string args)
d. static public int main(String[] args)
e.static void main(String[] args)

33、Map遍历

    for(Map.Entry<String, String>  entry : map.entrySet()){     
        System.out.println(entry.getKey()+"--->"+entry.getValue());     
    }  

 

34、for循环

for语句的格式为：

　　for (初始化语句; 条件语句; 控制语句)
　　{
　　　　语句1 ;
　　　　语句2 ;
　　　　....

　　　　语句n ;
　　}

　　　for 语句的执行顺序是：首先执行“初始化语句”；然后测试“条件语句”；若条件成立，则执行语句1到语句n；然后执行“控制”语句；接着再测试条件语句是否成立，如果成立则重复执行以上过程，直至条件不成立时才结束for循环。

35、 Java 内存模型

浅析java内存模型--JMM(Java Memory Model)

全面理解JAVA内存模型

2.1 Java 内存模型的基本原理

Java 内存模型，由于 Java 被设计为跨平台的语言，在内存管理上，显然也要有一个统一的 模型。系统存在一个主内存 (Main Memory) ， Java 中所有变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存 (Working Memory) ，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。

因为当线程处于不同的cpu中时，它各自的变量保存在各自cpu的寄存器或者高速缓存中，这样回事的变量对于其它线程暂时不可见。

 

2.2 Volatile 的内存工作原理

Volatile 是保证多个线程之间变量可见性的，也就是说一个线程对变量进行了写操作，另外一个线程能够获取它最新的值。

它的工作原理是，它对写和读都是直接操作工作主存的。（这个可以通过操作字节码看到）

 

2.3 Synchronized 的内存操作模型 :

Synchronized, 有两层语义，一个是互斥，一个是可见性。在可见性上面，它的工作原理有点不同：当线程进入同步块时，会从主存里面获取最新值，然后当线程离开同步块时，再把变量的值更新到主存。

http://tomyz0223.iteye.com/blog/1001778

 

 

36.删除一个文件夹内的所有文件和文件夹

 

File file = new File(imgPath);
if (!file.exists()) return;
deleteDirectory(file);


public void deleteDirectory(File path) {
		    if( path.exists() ) {
			      File[] files = path.listFiles();
			      for(int i=0; i<files.length; i++) {
				         if(files[i].isDirectory()) {
				      	   deleteDirectory(files[i]);
				         }
				         else {
				      	   files[i].delete();
				         }
			      }
		    }
	  }

 

37、关于JSP中的pageContext:

 

使用pageContext所设定的属性对象，其共享范围限于同一个JSP页面，

使用request所设定的属性对象，其在同一个request处理期间可以共享（包括forward给其它JSP页面），

session对象所设定的属性对象则限于同一个进程作用期间可以共享，

而application对象所设定的属性，则在整个Web应用程序中的JSP页面都可以共享。

 

 38，Final的初始化

 1.  final修饰的成员变量没有默认值 
2.  final初始化可以在三个地方 
    (1)声明的时候初始化 
    (2)构造函数里初始化 
    (3)要是没有static修饰的话可以在非静态块里初始化,要是有static修饰的话可以在静态块里初始化 
3.  使用final成员前要确保已经初始化，如果没初始化，或者初始化多次，则无法通过编译。

 

 39、一些转换技巧

Map<String, HandlerMapping> matchingBeans =
				BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);

	//map转换list
	List<HandlerMapping> handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
	
	//map判断空
	if (!matchingBeans.isEmpty())
	
	//数组转List (interceptors 数组)
	interceptorList.addAll(Arrays.asList(this.interceptors));
	
	//List转指定对象数组
	interceptors = this.interceptorList.toArray(new HandlerInterceptor[this.interceptorList.size()]);

 

40、java.lang.Number是所有基础类型的父类

public abstract class Number implements java.io.Serializable {
    
    public abstract int intValue();
    
    public abstract long longValue();
    
    public abstract float floatValue();
    
    public abstract double doubleValue();
    
    public byte byteValue() {
	return (byte)intValue();
    }
    
    public short shortValue() {
	return (short)intValue();
    }
}

 

public final class Long extends Number implements Comparable<Long> 

public final class Integer extends Number implements Comparable<Integer> 

 

 41、JDK、JRE、JVM

JDK：Java Development ToolKit

Java开发工具包

 

JRE：Java Runtime Environment

Java运行环境

 

JVM:Java Virtual Machine

Java虚拟机

 

JMM：Java Memory Model

Java内存模型

 

JDK是SUN公司发布的用于开发Java程序的工具包

在它的bin目录下有很多工具，常见的包括：javac.exe,java.exe,javadoc.exe等（其中有很多都是用Java编写的）各种版本的IDE工具也是需要使用JDK来完成编译，打包，运行等各种功能的。

 

JRE顾名思义，java的运行环境

JDK是开发工具，在它的安装目录下包含了JRE目录，其实在安装JDK时（1.4版本以上），有一个安装选项，如果勾上时，在Java的安装目录下会多一个JRE目录，这里的JRE与JDK下的JRE目录基本上是完全一致的，那么为什么需要两个JRE呢？

 

前面已经提到过，JDK的bin目录下的很多工具都是用Java编写的，使用这些工具的时候也是需要运行环境的，通过这些.exe包装器（这些包装器提供了寻找tools.jar中的一些java类的快捷方法，不需要输入一长串的包名和类名）来使用那些工具时，java会自动寻找父目录下的JRE，所以在这里放置了JRE。

 

JVM：Java虚拟机，在window下作为动态连接库（jvm.dll）存在，用于解释执行Java字节码。jvm.dll文件路径为：jre7\bin\server 

可以把它理解成是专门用来执行Java程序的一台机器。也就是说JVM提供了Java执行的硬件平台。JVM上执行的代码都存放在.CLASS文件中。JVM只执行字节码文件。

 

==================================================================

Java的跨平台如何体现：

JVM也是一个软件，不同的平台有不同的版本。我们编写的Java源码，编译后会生成一种 .class 文件，称为字节码文件。Java虚拟机就是负责将字节码文件翻译成特定平台下的机器码然后运行。也就是说，只要在不同平台上安装对应的JVM，就可以运行字节码文件，运行我们编写的Java程序。

注意：编译的结果不是生成机器码，而是生成字节码，字节码不能直接运行，必须通过JVM翻译成机器码才能运行。不同平台下编译生成的字节码是一样的，但是由JVM翻译成的机器码却不一样。

 

所以，运行Java程序必须有JVM的支持，因为编译的结果不是机器码，必须要经过JVM的再次翻译才能执行。即使你将Java程序打包成可执行文件（例如 .exe），仍然需要JVM的支持。

注意：跨平台的是Java程序，不是JVM。JVM是用C/C++开发的，不能跨平台，不同平台下需要安装不同版本的JVM。

 

 42、finalize()

Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。

finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

垃圾收集器只知道释放那些由new分配的内存，所以不知道如何释放对象的“特殊”内存。为解决这个问题

 

Java提供了一个名为finalize()的方法，它的工作原理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存。

所以如果使用finalize()，就可以在垃圾收集期间进行一些重要的清除或清扫工作(如关闭流等操作)。但JVM(Java虚拟机)不保证此方法总被调用。

 

43、原子操作AtomicInteger

public class AtomicLong extends Number
				implements Serializable

API 

不使用synchronized关键字，AtomicInteger通过另一种线程安全的方法实现加减操作。

AtomicInteger为什么能够达到多而不乱，处理高并发应付自如呢？

这是由硬件提供原子操作指令实现的，这里面用到了一种并发技术：CAS。在非激烈竞争的情况下，开销更小，速度更快。

Java.util.concurrent中实现的原子操作类包括：

 

AtomicBoolean、AtomicInteger、AtomicIntegerArray、AtomicLong、AtomicReference、AtomicReferenceArray。

 

J2SE 5.0提供了一组atomic class来帮助我们简化同步处理。

基本工作原理是使用了同步synchronized的方法实现了对一个long, integer, 对象的增、减、赋值（更新）操作. 比如对于++运算符, AtomicInteger可以将它持有的integer 能够atomic 地递增。在需要访问两个或两个以上 atomic变量的程序代码（或者是对单一的atomic变量执行两个或两个以上的操作）通常都需要被synchronize以便两者的操作能够被当作是一个atomic的单元。 

addAndGet(long delta) 
    //以原子方式将给定值添加到当前值。

getAndSet() : 
	//设置新值，返回旧值. 

compareAndSet(expectedValue, newValue) : 
	//如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值
	//如果更新成功，返回true, 否则返回false
	//换句话可以这样说: 将原子变量设置为新的值, 但是如果从我上次看到的这个变量之后到现在被其他线程修改了(和我期望看到的值不符), 那么更新失败 
	/*  单线程下, compareAndSet返回永远为true,      
     *  多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,      
     *  如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值 
	*/

int	incrementAndGet() 
          以原子方式将当前值加 1。

 

为了提高性能,AtomicLong等类在实现同步时,没有用synchronized关键字,而是直接使用了最低层(本地c语言实现代码)来完成的,

因而你是看不到用synchronized关键字的.

比如:AtomicLong类中原子操作方法:

public final boolean compareAndSet(long expect, long update) ;

就是直接使用SUN公司低层本地代码的原子方法(native方法):

public final native boolean compareAndSwapLong(...)来实现的.

 

Example:

import java.util.*;  
import java.util.concurrent.*;  
import java.util.concurrent.atomic.*;  
/* 
 * ava.util.concurrent中实现的原子操作类包括： 
AtomicBoolean、AtomicInteger、AtomicIntegerArray、AtomicLong、AtomicReference、 
AtomicReferenceArray。 
 *  
 */  
public class AtomicOperationDemo {  
       static AtomicInteger count=new AtomicInteger(0);  
       public static class AddThread implements Runnable{  
        @Override  
        public void run() {  
            for(int k=0;k<1000;k++){  
                count.incrementAndGet();  
            }  
         }   
       }  
	   
	   
       public static void AtomicIntShow(){  
         System.out.println("AtomicIntShow() enter");  
         ExecutorService threadpool =   Executors.newFixedThreadPool(10);  
           
		 //开100个线程  
         for(int k=0;k<100;k++){  
             threadpool.submit(new AddThread());  
         }  
           
         try {  
            Thread.sleep(2000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
           
         /* output 
          * AtomicIntShow() enter 
          * result of acumulated sum=100000 
          * AtomicIntShow() exit 
          */  
           
         System.out.println("result of acumulated sum="+count);  
         threadpool.shutdown();  
         System.out.println("AtomicIntShow() exit");  
         return ;  
          
    }  
}  


public class Maintest {  
    public static void main(String[] args) {  
        AtomicOperationDemo.AtomicIntShow();  
    }  
} 


结果：
/* output 
          * AtomicIntShow() enter 
          * result of acumulated sum=100000 
          * AtomicIntShow() exit 
          */  

 

 

44、Object、String类中equals方法的不同

StringBuffer / StringBuilder的equals方法都是继承的Object方法

String类中对equals方法进行了重写

 

Object类的equals方法的实现：

public boolean equals(Object obj) {
    return (this == obj);
}

 Object中的equals就是用==来比较当前对象和传入的参数的。

再看看String的equals实现：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
}

 它去比较内容了。

再看StringBuilder，在其源码里没有发现equals方法，那么它就继承了Object的实现，用==来比较传进来的参数。

我们看到equals是个实例方法（非static），实例方法是可以被子类重写而去实现自己想要的行为的，因此，不能轻易的说equals就是比较内容的，其行为是特定于实现的。但==确实是比较地址的。因为java中不支持（至少现在不支持）运算符重载，我们不能改变==的含义，其行为是固定死的。

记得下次不要说“==比较地址，equals比较内容”这样的话了，如果要说，也在前面加上特定的条件，如“如果比较String”，勿断章取义。

 

 45、不借助中间变量交换元素

a = a + b
b = a - b 
a = a - b 

 

46.UUID

UUID(Universally Unique Identifier)

全局唯一标识符

是指在一台机器上生成的数字，是1.5中新增的一个类，在java.util下，用它可以产生一个号称全球唯一的ID

按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。

由以下几部分的组合：当前日期和时间(UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同)，时钟序列，全局唯一的IEEE机器识别号（如果有网卡，从网卡获得，没有网卡以其他方式获得），UUID的唯一缺陷在于生成的结果串会比较长。 

 

JDK1.5 

如果使用的JDK1.5的话,那么生成UUID变成了一件简单的事,以为JDK实现了UUID: 

java.util.UUID,直接调用即可. 

String s = UUID.randomUUID().toString();  

 

UUID是由一个十六位的数字组成,表现出来的形式例如 

550E8400-E29B-11D4-A716-446655440000   

 

47、获取随机数

法1：

int num = getRandom(1000);
  
public static int getRandom(int num) {
	return (int) Math.round(Math.random() * num);
}

 API：

double java.lang.Math.random()

//Returns a double value greater than or equal to 0.0 and less than 1.0

 

long java.lang.Math.round(double a)

 

 

法2：

Random random = new Random();
int num = random.nextInt(50);

 API：

int java.util.Random.nextInt(int n)

//Returns a int value between 0 (inclusive) and the specified value (exclusive), 

 

公共方法：

public static final String allChar = "023456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ";
    public static final String numberChar = "023456789";

    /*
     * 获取随机字符串
     */
    public static String generateString(int length){  //参数为返回随机数的长度
		StringBuffer sb = new StringBuffer();
		Random random = new Random();
		for (int i = 0; i < length; i++) {
			sb.append(allChar.charAt(random.nextInt(allChar.length())));
		}
		return sb.toString();
    }
    
    public static String generateNumber(int length){  //参数为返回随机数的长度
		StringBuffer sb = new StringBuffer();
		Random random = new Random();
		for (int i = 0; i < length; i++) {
			sb.append(numberChar.charAt(random.nextInt(numberChar.length())));
		}
		return sb.toString();
    }

 

 48、request.getParameterMap()

在servlet中GET请求可以通过HttpServletRequest的getRequestURL方法和getQueryString()得到完整的请求路径和请求所有参数列表，

POST的需要getParameterMap()方法遍历得到，

不论GET或POST都可以通过getRequestURL+getParameterMap()来得到请求完整路径

 

request.getParameterMap()的返回类型是Map类型的对象，也就是符合key-value的对应关系，但这里要注意的是，value的类型是String[],而不是String. 

得到jsp页面提交的参数很容易,但通过它可以将request中的参数和值变成一个map，以下是将得到的参数和值 

打印出来，形成的map结构：map(key,value[])，即：key是String型，value是String型数组。 

例如：request中的参数t1=1&t1=2&t2=3 

形成的map结构： 

key=t1;value[0]=1,value[1]=2 

key=t2;value[0]=3 

如果直接用map.get("t1"),得到的将是:Ljava.lang.String; value只所以是数组形式，就是防止参数名有相同的 

情况。 

public class ParamsUitl {

	public static Map<String, String> getParamsMap(HttpServletRequest request) {
		Map<String,String> params = new HashMap<String,String>();
		Map requestParams = request.getParameterMap();
		for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {
			String name = (String) iter.next();
			String[] values = (String[]) requestParams.get(name);
			String valueStr = "";
			for (int i = 0; i < values.length; i++) {
				valueStr = (i == values.length - 1) ? valueStr + values[i]
						: valueStr + values[i] + ",";
			}
			valueStr = new String(valueStr);
			params.put(name, valueStr);
		}
		return params;
	}	
}

 

 49.特殊字符过滤

private String formatString(String oldStr){
		String regEx="[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？\r\n|\r|\n|\n\r]";  
        Pattern   p   =   Pattern.compile(regEx);     
        Matcher   m   =   p.matcher(oldStr);     
		return m.replaceAll("").trim();
	}

 

 50.整数相除保留小数

java中，当两个整数相除时，由于小数点以后的数字会被截断，运算结果将为整数，此时若希望得到运算结果为浮点数，必须将两整数其一或是两者都强制转换为浮点数。 
例如： 
(float)a/b // 将整数其中一个强制转换为浮点数，再与另一个整数相除 
a/(float)b 
(float)a/(float)b // 将两个整数同时强制转换为浮点数后再相除 

float num= (float)2/3;
DecimalFormat df = new DecimalFormat("0.00");//格式化小数
String s = df.format(num);//返回的是String类型

 

51、new File(File parent, String child)

File home = new File(getCatalinaBase());
File conf = new File(home, "conf");
File properties = new File(conf, "catalina.properties");

 parent下的目录或文件 的File对象

 

 52、为啥final类型的map或者arraylist可以修改数据 而final类型的String变量不可以修改数据呢

比如 

final   Map  map =new  HashMap();    可以往map里put数据

final   List  list =new  ArrayList();   可以往list里add数据

但是   final   String    s =“123”；     然后s就不可修改数据了

同样是final    为啥map和list可以修改    但是string不可以修改呢 

 

答：

final 只是表示引用不可以修改，如果你先写final   Map  map =new  HashMap(); 再写 map =new  HashMap(); 同样会报错

 

map和list只是个地址，final的意思是地址不能改，但是地址指向的内容当然可以改。

final的意思是一个已初始化的变量不能再指向另外的值/对象

 

53、BigDecimal保留2位小数

public class test1_format {

    public static void main(String[] args) {
        BigDecimal decimal = new BigDecimal("1.12345");
        System.out.println(decimal);
        BigDecimal setScale = decimal.setScale(4,BigDecimal.ROUND_HALF_DOWN);
        System.out.println(setScale);
        
        BigDecimal setScale1 = decimal.setScale(4,BigDecimal.ROUND_HALF_UP);
        System.out.println(setScale1);
    }
}

 

 
 

..

 

54、订单的动态字符串

if(ret.getCode() == 0){
	if(response.exists("lOrderId") && response.exists("Id")){
		//整理订单商品
		OrderUtil.formatOrderProducts(response.get("lOrderId"));
		
		result.setIntegerValue("orderId", ..);
		...
		result.setIntegerValue("code", 0);
	}
}else{
	 result.setIntegerValue("code", -10);
}
       
	   
/*
 * 整理订单
 */
public static void formatOrderProducts(Integer orderId) {
	itemsGood = getOrderProducts(orderId);
	if(itemsGood != null){
		StringBuffer strOrderGoodsList = new StringBuffer("[");
		int i=1;
		for(T itemGood : itemsGood){
			strOrderGoodsList.append("{\"lOrderProductId\":" + itemGood.get("lBuyerOrderProductId"));
			if(itemGood.exists("lBuyerId")){
				strOrderGoodsList.append(",\"lBuyerId\":" + itemGood.get("lBuyerId"));
			}
			
			strOrderGoodsList.append(",\"lGoodsId\":" + itemGood.get("nProductId") + "," +
					"\"strLogoURL\":\"" + itemGood.getStringValue("strLogoURL") + "\","+
					"\"nState\":\"" + itemGood.get("nState") + "\","+
					"\"nType\":\"" + itemGood.get("nType") + "\","+
					"\"nComponent\":\"" + itemGood.get("nComponent") + "\"," + 
					"\"nIsValue\":\"" + itemGood.get("nIsValue") + "\",");
			
			if(itemGood.exists("nRefundBackId")){
				if(itemGood.get("nRefundBackId") > 0){
					strOrderGoodsList.append("\"nRefundId\":\"" + itemGood.get("nRefundBackId") + "\"," + "\"nRefundType\":\"" + itemGood.get("nRefundType") + "\"," +  "\"nRefundState\":\"" + itemGood.get("nOrderState") + "\",");
					if(itemGood.exists("strTrackingCode"))
						strOrderGoodsList.append("\"strTrackingCode\":\"" + itemGood.getStringValue("strTrackingCode") + "\"," );
			
				}
			}
			strOrderGoodsList.append("\"strGoodsTitle\":\"" + itemGood.getStringValue("strProductTitle") + "\",\"nPrice\":\"" + itemGood.getStringValue("nMallPrice") + 
					"\",\"nCount\":" + itemGood.get("nQuantity") + ",\"lCategoryId\":\"" + itemGood.getStringValue("nProductCategory") + "\"}");
			if (itemsGood.length > i) {
				strOrderGoodsList.append(",");
			}
			i++;
		}
		
		strOrderGoodsList.append("]");
		
		//更新主订单中strOrderGoodsList字符串
		updateOrderGoodsList(orderId,strOrderGoodsList.toString());
	}
}	   
	   

 

 55、如何逆转字符串

a、org.apache.commons.lang.StringUtils

StringUtils.reverse 本质还是第二种方法

 

b、new StringBuffer(res).reverse()

 

c、利用最简单的交换两个变量的值的方法，即 t = a, a = b, b = t这样的方式

char* Reverse(char* str, int length)
{
	for (int i = 0; i < length / 2; ++i)
	{
		str[length] = str[i];
		str[i] = str[length - 1 - i];
		str[length - 1 - i] = str[length];
	}
	str[length] = 0;
	return str;
}

 56、JAVA中有那些类是Final的？？

https://blog.csdn.net/dgeek/article/details/53425192

 所有包装类：Boolean，Character，Short，Integer，Long，Float，Double，Byte，Void

字符串类：String，StringBuilder，StringBuffer

系统类：Class，System，RuntimePermission，Compiler

数学类：Math，StrictMath

其他：Character.UnicodeBlock，ProcessBuilder，StackTraceElement

 

57、简要描述String、StringBuffer、StringBuilder的区别

可变性、线程安全、性能三个方面

可变性

String类，final类，使用字符数组保存字符串，private final char value[]，所以string对象是不可变的。

StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。

 

线程安全性

String中的对象是不可变的，也就可以理解为常量，线程安全。

StringBuffer对方法加了同步锁synchronized或者对调用的方法加了同步锁，所以是线程安全的。

StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

 

性能

每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

 

58、char型变量中能不能存贮一个中文汉字?为什么?

在C语言中，char类型占1一个字节，而汉子占2个字节，所以不能存储。

 

在Java中，char类型占2个字节，而且Java默认采用Unicode编码，一个Unicode码是16位，所以一个Unicode码占两个字节，Java中无论汉子还是英文字母都是用Unicode编码来表示的。所以，在Java中，char类型变量可以存储一个中文汉字。

 

 

59、TOMCAT最大链接数多少？

设置tomcat下conf文件夹的server.xml文件

 

maxThreads="150"  表示最多同时处理150个连接 

minSpareThreads="25" 表示即使没有人使用也开这么多空线程等待 

maxSpareThreads="75" 表示如果最多可以空75个线程，例如某时刻有80人访问，之后没有人访问了，则tomcat不会保留80个空线程，而是关闭5个空的。 

acceptCount="100" 当同时连接的人数达到maxThreads时，还可以接收排队的连接，超过这个连接的则直接返回拒绝连接。 

 

60、java.util.Date和java.sql.Date的区别和相互转化

共同点：都有getTime方法返回毫秒数，可以直接构建

不同点：

1、java.sql.Date是针对SQL语句使用的，它只包含日期而没有时间部分，一般在读写数据库的时候用，PreparedStament的setDate()的参数和ResultSet的getDate()方法的都是java.sql.Date

2、java.util.Date是在除了SQL语句的情况下面使用，一般是日常日期字段

3、java.util.Date 是 java.sql.Date 的父类，即：继承关系：java.lang.Object --》 java.util.Date --》 java.sql.Date

 

相互转化：

//java.sql.Date转为java.util.Date

java.sql.Date date=new java.sql.Date();
java.util.Date d=new java.util.Date (date.getTime());

//java.util.Date转为java.sql.Date

java.util.Date utilDate=new Date();
java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());
java.util.Date utilDate=new Date();

 

61、覆盖hashCode()方法的原则：

一定要让那些我们认为相同的对象返回相同的hashCode值

尽量让那些我们认为不同的对象返回不同的hashCode值，否则，就会增加冲突的概率。

尽量的让hashCode值散列开（两值用异或运算可使结果的范围更广）

 

62、System.out.println(4 | 3) 输出什么

答案：7

00000100 00000011 = 00000111 既是1+2+4= 7; 这个是按位或运算 ,只要有一个为1就得1,那么结果就是三个1,结果为7!

 

 

...

易错题：

1、

int j = 0;
        j = j++;
        System.out.println(j);

 没见过此题的人，大部分人可能得到的结果是：1。 然而，运行的结果会令您彻底失望。这是什么原因呢？原来Java编译器处理后缀++或--时是这么处理的：java的编译器在遇到j＋＋和j- -的时候会重新为变量运算分配一块内存空间，以存放原始的值，而在完成了赋值运算之后，将这块内存释放掉。即JAVA先将j的值保存到临时内存空间中，然 后处理++，即原来的j加1，此时原来的j变成1，然后再执行赋值，将内存空间中所存放的原来的值赋回给j，所以j仍然是0。C#和Java的结果是一样 的。

相反，C/C++不是这么处理的：C中是通过寄存器作中转先把j的值赋给它本身，再执行++的操作，这样结果就是1了。

2、

String a = "abc";   
        String b = "abc";   
        System.out.println("====>"+ a==b ); //"+"的优先级比"=="高，实际比较的是"====>abc"与abc  false
        System.out.println("====>"+ (a==b) );                    //true

 

3、一眼能说出它的结果

 

public class MainTest {

	public static void main(String[] args) {
		String s = null;  
        s = s+"word";  
        System.out.println("hello " +s);  
	}

}

 结果：hello nullword

String s = null;    
        //s = s+"word";    
        System.out.println("hello " +s); 

//结果：hello null

 String s = null 与 s="" 有什么区别？

s是一个String类的引用，null表示它不指向任何字符串对象，""表示s指向一个长度为0的字符串对象。如果调用s.length()之类的方法，s为null时会抛出NullPointerException，而""则能进行正常的计算。  

 

 

 

抽象类中可以有抽象方法和非抽象方法 ！

 

构造方法可以被重载，但不可以被重写

 

数组没有 length() 这个方法，有 length 的属性。 String 有有 length() 这个方法。

 

                Scanner scanner = new Scanner(System.in);
                 String temp = scanner.nextLine();
                 System.out.println("temp=="+temp);
// 输入。。。

 

 

 

new String(name.getBytes("iso-8859-1"),"utf-8");

 

 

其他：

 java类成员变量在没有赋值的时候会赋以默认值，其它局部变量是不能够享受这种待遇的。