Java基础知识总结

Posted 2020-06-24 chuquan.ou

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java基础知识总结相关的知识，希望对你有一定的参考价值。

JVM

W3C JAVA教程

JAVA考古学

StringBuffer 和StringBuilder中的两个函数：

Java代码

//int indexOf(String str) ：返回当前StringBuffer对象中，第一个满足str子串的位置。
//int indexOf(String str, int fromIndex) ：从fromIndex开始查找，返回第一个满足str子串的位置。
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
System.out.println("sb.indexOf(\\"is\\") = " + sb.indexOf("is")); //2
System.out.println("sb.indexOf(\\"is\\", 4) = " + sb.indexOf("is", 4)); //5
System.out.println("sb.indexOf(\\"is\\", 4) = " + sb.indexOf("is", 7)); // -1
//StringBuffer insert(int offset, String str)
//在当前StringBuffer对象中插入一个元素，在索引号offset处插入相应的值。
StringBuffer sf = new StringBuffer("..{..}) public class ESBYSYSInquiryMachineInfoSrvRequest {");
int classIdx = sf.indexOf("public class ");
if(classIdx > 0){
sf.insert(sf.indexOf("{", classIdx), " implements java.io.Serializable");
}
System.out.println(sf.toString());
//..{..}) public class ESBYSYSInquiryMachineInfoSrvRequest implements java.io.Serializable{

2.保留2位小数：

Java代码

import java.text.DecimalFormat;
DecimalFormat df=new DecimalFormat("0.00");
Double x = 83.3333333333;
x=Double.parseDouble(df.format(x));

3.group by 和 order by

Java代码

ORDER BY 用于对数据按指定的列和方法排序。
select * from syscolumns order by id asc, colorder desc;
指示查询出的结果按 id 正序排列， colOrder 逆序排列。
GROUP BY 用于汇总统计。 HAVING 用途和 WHERE类似，但用于对 GROUP BY 的结果进行过滤。
select id, count(id) from syscolumns group by id;
这条语句以 id 进行汇总，统计出每个不同的 id 出现的个数。
select id, count(id) from syscolumns group by id having count(1) > 10;
这条语句以 id 进行汇总，统计出每个不同的 id 出现的个数，但 having 后的条件指定了只显示 count(id) 大于 10 的数据。。
先Group by ，后 Order by

4.日期

获取当前时间：

Java代码

1.
SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-dd" + " " + "hh:mm:ss");
String datetime = tempDate.format(new java.util.Date());
2.
Calendar now=Calendar.getInstance();
String time=now.get(Calendar.YEAR)+"-"+(now.get(Calendar.MONTH)+1)+"-"+now.get(Calendar.DAY_OF_MONTH)+" "+now.get(Calendar.HOUR_OF_DAY)+":"+now.get(Calendar.MINUTE)+":"+now.get(Calendar.SECOND);
3.Date curDate= new Date(System.currentTimeMillis());

SimpleDateFormat format = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" ); //24小时制
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//12小时制

a.获取年、月、日：

Java代码

String year=String.valueOf(c.get(Calendar.YEAR));
String month=String.valueOf(c.get(Calendar.MONTH)+1);
String day=String.valueOf(c.get(Calendar.DAY_OF_MONTH));

b.Calendar和Date的转化

(1) Calendar转化为Date

Java代码

Calendar cal=Calendar.getInstance();
Date date=cal.getTime();

(2) Date转化为Calendar

Java代码

Date date=new Date();
Calendar cal=Calendar.getInstance();
cal.setTime(date);

c.计算一年中的第几星期

(1)计算某一天是一年中的第几星期

Java代码

Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH,1);
cal.set(Calendar.DAY_OF_MONTH, 3);
int weekno=cal.get(Calendar.WEEK_OF_YEAR);

(2)计算一年中的第几星期是几号

Java代码

SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.WEEK_OF_YEAR, 1);
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
System.out.println(df.format(cal.getTime()));
输出:
2006-01-02

1天内（注意为add ）：

Java代码

Calendar c=Calendar.getInstance();
c.add(Calendar.DAY_OF_MONTH, -1); //得到前一天的时间
startDateStr=sf.format(c.getTime());
endDateStr=sf.format(java.util.Calendar.getInstance().getTime()); 推荐使用这种方法获取当前时间，不推荐使用new Date()

3天内：

Java代码

Calendar c=Calendar.getInstance();
c.add(Calendar.DAY_OF_MONTH, -3); //得到前3天的时间
startDateStr=sf.format(c.getTime());

近1月：

Java代码

Calendar c=Calendar.getInstance();
c.add(Calendar.MONTH, -1);
startDateStr=sf.format(c.getTime());

到当前时间的前几年的时间：

Java代码

Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, -5);//得到前5年
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String mDateTime=formatter.format(c.getTime());
String strStart=mDateTime.substring(0, 16);//2002-10-24 09:30

本月（注意为set ）：

Java代码

Calendar c=Calendar.getInstance();
c.set(Calendar.DATE,1); //把日期设为当月第一天
startDateStr=sf.format(c.getTime());

上月：

Java代码

Calendar c2=Calendar.getInstance();
c2.add(Calendar.MONTH,-1);
c2.set(Calendar.DATE,1);
startDateStr=sf.format(c2.getTime());

5.文本域input的不可编辑属性 disabled 和 readonly 区别

都可以实现都可以实现input的不可编辑，但有区别...

disable 属性 -- 表示已经失效的输入域

readonly 属性 -- 表示只读(只能看到,不能修改)的输入域(框)

Java代码

<input type="checkbox" value="2" name="fav" disabled="disabled" />
<input type="text" name="notinput" readonly="readonly" />

Java代码

/**是否闰年
*/
public boolean isLeapYear(int year) {
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }

具体日期操作：

http://www.360doc.com/content/09/0820/17/236102_5085810.shtml

可将选中的代码拖动到QQ聊天窗口中复制

6.File协议

　　表示本地文件传输协议，File协议主要用于访问本地计算机中的文件，就如同在Windows资源管理器中打开文件一样。
　　应用：要使用File协议，基本的格式如下：file:///文件路径，比如要打开F:盘flash文件夹中的1.swf文件，那么可以在资源管理器或IE地址栏中键入：file:///f:/flash/1.swf并回车。

3个斜杠代表本地

8.substring(int beginIndex, int endIndex)

该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
    示例：
         "hamburger".substring(4, 8) returns "urge"
         "smiles".substring(1, 5) returns "mile "
    参数：
        beginIndex - 起始索引（包括）。
        endIndex - 结束索引（不包括）。

9.什么时候用Thread.getContextClassLoader()

需要动态加载很多类和资源的时候 .

通常当你需要动态加载资源的时候 , 你至少有三个 ClassLoader 可以选择 :

² 系统类加载器或叫作应用类加载器 (system classloader or application classloader)

² 当前类加载器

² 当前线程类加载器

10.instanceof 运算符
指出对象是否是特定类的一个实例。

Java代码

String s = "I AM an Object!";
boolean isObject = s instanceof Object;
public double calculate(Bill bill) {
　　if (bill instanceof PhoneBill) {
　　//计算电话账单
　　}
}

11、java环境配置(都放下面)：

CLASSPATH .;%JAVA_HOME%\\lib

JAVA_HOME C:\\Program Files\\Java\\jdk1.6.0_22

Path .;%JAVA_HOME%\\bin

13.JDK1.5的新特性

“JDK1.5”（开发代号猛虎）的一个重要主题就是通过新增一些特性来简化开发 ，这些特性包括泛型，for-each循环，自动装包/拆包，枚举，可变参数,　静态导入。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。

自动装包/拆包

自动装包/拆包大大方便了基本类型数据和它们包装类地使用。
自动装包：基本类型自动转为包装类.(int　>>　Integer)
自动拆包：包装类自动转为基本类型.(Integer　>>　int)
在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类。

这里Integer先自动转换为int进行加法运算，然后int再次转换为Integer.

Java代码

int　a　=　3;
Collection　c　=　new　ArrayList();
c.add(a);//自动转换成Integer.
Integer　b　=　new　Integer(2);
c.add(b　+　2);

枚举：

Java代码

public　enum　Color
{
　　　Red,
　　　White,
　　　Blue
}

然后可以这样来使用Color　myColor　=　Color.Red.
枚举类型还提供了两个有用的静态方法values()和valueOf().　我们可以很方便地使用它们，例如

Java代码

for　(Color　c　:　Color.values())
　　　System.out.println(c);

带构造函数的枚举：

Java代码

public enum Color {
RED("红色"),BLUE("蓝色"),GREEN("绿色");
private final String name;
public String getName() {
return name;
}
private Color(String name){
this.name=name;
}
}

Java代码

System.out.println("Color.RED.name():"+Color.RED.name()); //RED
System.out.println("Color.RED.toString():"+Color.RED.toString()); //RED
System.out.println(Color.RED.getName()); //红色

Color.RED.name()

Color.RED.toString(); 得到的都是RED

1、Color枚举类是特殊的class，其枚举值(RED,BLUE...)是Color的类对象(类实例)：Color c=Color.RED ;
而且这些枚举值都是public static final的，也就是我们经常所定义的常量，因此枚举类中的枚举值最好全部大写。
2、即然枚举类是class，当然在枚举类型中有构造器，方法和数据域。但是，枚举类的构造器有很大的不同：
(1) 构造函数只是在构造枚举值的时候被调用。
(2) 枚举构造函数只能私有private ，绝对不允许有public构造器。这样可以保证外部代码无法新构造枚举类的实例。因为我们知道枚举值是public static final的常量而已但枚举类的方法和数据域可以允许外部访问。

Java代码

/**
*
* 服务器类型
*
*/
public enum ServerType {
JBoss("server/default/deploy","client,common"), WebLogic("",""), GlassFish("","");
private String deployPath;
private String libClassPath;
private ServerType(String deployPath, String libClassPath){
this.deployPath = deployPath;
this.libClassPath = libClassPath;
}
public String getDeployPath(){
return this.deployPath;
}
public String getLibClassPath(){
return this.libClassPath;
}
}

ServerType serverType = ServerType.JBoss;

String deployPath = serverType.getDeployPath();
String libClassPath = serverType.getLibClassPath();

可变参数：

当不能确定一个方法的入口参数的个数时，以往版本的Java中，通常的做法是将多个参数放在一个数组或者对象集合中作为参数来传递，1.5版本以前的写法是：

Java代码

int sum(Integer[] numbers)　　
{　　
　　int nSum = 0;　　
　　for(int i: numbers)　　
　　nSum += i;　　
　　return nSum;　　
}

在别处调用该方法　　
sum(new Integer[] {12,13,20});

而在1.5版本中可以写为：

Java代码

public static int sum(Integer... number){
int nSum=0;
for(int i : number){
nSum+=i;
}
return nSum;
}

在别处调用该方法

Java代码

System.out.println("sum():"+sum(12,13,14));
System.out.println("sum():"+sum(12,13));

静态导入：

要使用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。
不过，过度使用这个特性也会一定程度上降低代码地可读性。

Java代码

import　static　java.lang.Math.*;
…….
r　=　sin(PI　*　2);　//无需再写r　=　Math.sin(Math.PI);

14.o1.CompareTo(o2);

整形间比较会返回1、-1、0

如：

Java代码

public static void main(String[] args) {
//Integer num1;
//num1 = new Integer("24");
//Integer num2;
//num2 = new Integer("34");
Integer num2=12; //不可使用 int num2=12;因compareTo(T t)中的T是类，所以必须用包装类
Integer num1=11;
System.out.println(num2.compareTo(num1));
//1 System.out.println("------------------");
System.out.println(num1.compareTo(num2));
//-1 }

字符串间比较：

"abcd" .compareTo( "adef" )== -2

"abc" .compareTo( "abcdef" )== -3

"abc" .compareTo( "abc" ) == 0

简单 字符串的排序 。（例如使用 compareTo 进行姓名的排序）

Java代码

//需要进行排序的字符串
String[] array = new String[] { "lilei", "libai", "james", "poly",
"wobfei" };
//使用简单的循环排序
for (int i = 0; i < array.length ; i++) {
for (int j = i + 1; j < array.length-1; j++) {
if (array[i].compareTo(array[j]) > 0) {
String temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}

使用上面针对 String 的排序以后，字符串的内容将会是：

james libai lilei poly wobfei

该例子来源(稍作了修改)：http://wobfei.iteye.com/blog/743123

15.编码习惯

add、saveAdd

edit、saveEdit

16、Math.round();

Math.round(m) = (int)Math.floor(a + 0.5f)

Math.ceil(x):比x大的最小值。
Math.round(x)：四舍五入。
Math.floor(x):比x小的最大值。

jdk说得很明白了，
-11.5+0.5=-11 Math.floor(-11)=-11
-11.3+0.5=-10.8 Math.floor(-10.8)= -11
-11.8+0.5=-11.3 Math.floor(-11.3)= -12

17、重写

关于重写，遵循以下的规则：

（1）重写方法必须和被重写方法具有相同的参数列表，返回类型必须和被重写方法的返回类型相同或者是返回类型的子类型。

（2）重写方法的访问控制修饰符不能比被重写方法更严格（比如一个在父类中声明为public的方法重写成一个protected的方法）。

18.

Java代码

class Test {
void test(int i) {
System.out.println("I am an int." + i);
}
void test(String s) {
System.out.println("I am a string.");
}
public static void main(String args[]) {
Test t = new Test();
char ch = \'y\';
t.test(ch);
}
//结果为：I am an int.121
}

19.JDBC的主要任务是什么？（三个）

1、建立与数据库的连接。
2、向数据库发起查询请求。
3、处理数据库返回结果。

20.TreeSet的构造函数

TreeSet();

TreeSet(Collection c);//构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序 进行排序。

TreeSet(Comparator comparator);//构造一个新的空 TreeSet，它根据指定比较器进行排序。

Java代码

public class NameComparator implements Comparator<Name>{
public int compare(Name n1,Name n2){
if(n1.getName().compareTo(n2.getName())>0) return -1;
if(n1.getName().compareTo(n2.getName())<0) return 1;
return 0;
}
public static void main(String[] args) {
Set<Name> set = new TreeSet<Name>(new NameComparator());
Name n1 = new Name("ray");
Name n2 = new Name("tom");
Name n3 = new Name("jame");
set.add(n1);
set.add(n2);
set.add(n3);
Iterator it = set.iterator();
while(it.hasNext()){
Name s = (Name)it.next();
System.out.print(s.getName()+",");
}
System.out.println("一共有对象："+set.size()+"个");
}
}//打印结果是：tom,ray,jame,一共有对象：3个

客户端排序时因为java.util.Comparator<Type>接口提供了具体的排序方式，<Type>指定了被比较对象的类型，Comparator有个compare(Type x,Type y)的方法，用于比较两个对象的大小。

21.Object中的hashcode()和equals()

   在Java中任何一个对象都具备equals(Object obj)和hashcode()这两个方法，因为他们是在Object类中定义的。
equals(Object obj)方法用来判断两个对象是否“相同”，如果“相同”则返回true，否则返回false。
hashcode()方法返回一个int数，在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。
    接下来有两个个关于这两个方法的重要规范(我只是抽取了最重要的两个,其实不止两个)：
规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是：“如果两个对象相同，那么他们的hashcode应该相等”。不过请注意：这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。
规范2：如果equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的hashcode可能相同”。
     根据这两个规范，可以得到如下推论：
1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。
2、如果两个对象不equals，他们的hashcode有可能相等。
3、如果两个对象hashcode相等，他们不一定 equals。
4、如果两个对象hashcode不相等，他们一定不 equals。

http://www.iteye.com/topic/800929

22.序列化

序列化的对象要实现Serializable接口,
Serializable接口没有需要实现的方法，
implements Serializable只是为了标注该对象是可被序列化的，
然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

实现序列化（保存到一个文件）的步骤
a）Make a FileOutputStream
      FileOutputStream fs = new FileOutputStream("foo.ser");
b）Make a ObjectOutputStream
      ObjectOutputStream os = new ObjectOutputStream(fs);
c）write the object
     os.writeObject(myObject1);
     o s.writeObject(myObject2);
     os.writeObject(myObject3);
d) close the ObjectOutputStream
     os.close();

23、计划任务：

java.util.Timer

timer.schedule(...);

http://www.blogjava.net/georgehill/archive/2005/06/09/5793.aspx

http://www.klstudio.com/post/187.html

24.Split

在java.lang包中有String.split()方法，返回是一个数组
我在应用中用到一些，给大家总结一下，仅供大家参考：
1、如果用“.”作为分隔的话，必须是如下写法：String.split("\\\\."),这样才能正确的分隔开，不能用String.split(".");
2、如果用“|”作为分隔的话，必须是如下写法：String.split("\\\\|"),这样才能正确的分隔开，不能用String.split("|");
“.”和“|”都是转义字符，必须得加"\\\\";
3、如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“acount=? and uu =? or n=?”,把三个都分隔出来，可以用String.split("and|or");

java转义字符

     \\"：双引号
     \\\'：单引号
     \\\\：反斜线

25.作用范围：

this.context.setAttribute(MyConstants.CONTINENTS_KEY, continentlist);
public static final String CONTINENTS_KEY="CONTINENTS";
jsp页面中可以直接使用 CONTINENTS（${CONTINENTS }），而无需context.getAttribute("");

Java代码

<body>
<% request.setAttribute("name","xiaoming") ;%>
<input type="text" value="${name}"/>
</body>

26.数组转为list

Java代码

List stooges = Arrays.asList("Larry", "Moe", "Curly");

此时stooges中有有三个元素。注意：此时的list不能进行add操作，否则会报 “java.lang.UnsupportedOperationException”，Arrays.asList()返回的是List,而且是一个定长的List，所以不能转换为ArrayList，只能转换为AbstractList
原因在于asList()方法返回的是某个数组的列表形式,返回的列表只是数组的另一个视图,而数组本身并没有消失,对列表的任何操作最终都反映在数组上. 所以不支持remove,add方法的

Java代码

String[] arr = {"1", "2"};
List list = Arrays.asList(arr);

其他方式：

Java代码

String[] strArray = new String[] { "aa", "bb" };
List<String> list = new ArrayList<String>(Arrays.asList(strArray));
list.add("cc");
System.out.println(list);

结果：[aa, bb, cc]

27、使用ResourceBundle读取properties文件

有时候有些简单的配置文件可以没必要使用xml，其实ResourceBundle类就已经做的很好的。它甚至可以搜索到classpath里的jar文件中一些properties文件。

例如在jar文件中的根目录放置一个文件：test.properties，然后只要这个jar文件在classpath里。就可以使用这样的语句来获得一些属性：

Java代码

ResourceBundle rb = ResourceBundle.getBundle("test");
String s = rb.getString("FirstKey");
System.out.println(s);

28、HttpClient学习

Java代码

public class TestHttpClient {
public static void main(String[] args) {
String url = "http://images.gta-travel.com/HH/Images/HX/HKGA/HKGA-REG-1.jpg|http://images.gta-travel.com/HH/Images/HX/HKGA/HKGA-REG-2.jpg";
String[] urlArr = url.split("\\\\|");
String fileName = "D:\\\\httpClient";
HttpClient client = new HttpClient();
GetMethod method = new GetMethod(urlArr[1]);
// 使用 GET 方法，如果服务器需要通过 HTTPS 连接，那只需要将下面 URL 中的 http 换成 https
FileOutputStream output = null;
try {
client.executeMethod(method);
File showFile = new File(fileName + ".jpg");
output = new FileOutputStream(showFile);
output.write(method.getResponseBody()); //method.getResponseBody()为byte[]类型
output.flush();
} catch (HttpException e) {
} catch (IOException e) {
} finally {
if (output != null) {
try {
output.close();
output = null;
} catch (IOException e) {
}
}
}
}
}

http://www.blogjava.net/Alpha/archive/2007/01/22/95216.html

29、栈、堆

1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.
2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）
3. 堆：存放所有new出来的对象。
4. 静态域：存放静态成员（static定义的）
5. 常量池：存放字符串常量和基本类型常量（public static final）。
6. 非RAM存储：硬盘等永久存储空间
这里我们主要关心栈，堆和常量池，对于 栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。
对于字符串：其对象的引用都是存储在栈中的，如果是 编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

new String("China");
对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。这也就是有道面试题：String s = new String(“xyz”);产生几个对象？一个或两个，如果常量池中原来没有”xyz”,就是两个。

对于成员变量和局部变量：成员变量就是方法外部，类的内部定义的变量；局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。
形式参数是局部变量，局部变量的数据存在于栈内存中。栈内存中的局部变量随着方法的消失而消失。
成员变量存储在堆中的对象里面，由垃圾回收器负责回收

http://www.iteye.com/topic/634530

30.try-catch

Java代码

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;
}
}
}

Java代码

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

Java代码

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运行时传递给所运行类的参数,你这个类需要参数就传,不需要就不传.

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遍历

Java代码

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 内存模型

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.删除一个文件夹内的所有文件和文件夹

Java代码

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、一些转换技巧

Java代码

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()]);

以上是关于Java基础知识总结的主要内容，如果未能解决你的问题，请参考以下文章

Java基础总结大全（实用）

软帝学院：一万字的Java基础知识总结大全（实用）

Java基础学习JVM知识点总结面试题形式

Java基础+集合+多线程+JVM 面试题总结

JAVA快速入门总结

JVM面试题总结及分析