Java开发一些小的思想与功能小记(二)

1.用if+return代替复杂的if...else(if+return)

    public static void test1(String str) {
        if ("1".equals(str)) {
            System.out.println("输入的参数是1");
            return;
        }
        if ("2".equals(str)) {
            System.out.println("输入的参数是2");
            return;
        }
        if ("3".equals(str)) {
            System.out.println("输入的参数是3");
            return;
        }
        System.out.println("你输入的不是123`````````");
        // ...这里可以写不满足上述条件的处理
    }

2.尽量减少对变量的重复计算(for循环的用法)

明确一个概念，对方法的调用，即使方法中只有一句语句，也是有消耗的，包括创建栈帧、调用方法时保护现场、调用方法完毕时恢复现场等。所以例如下面的操作：

for (int i = 0; i < list.size(); i++)
 
{...}

建议替换为：

for (int i = 0, int length = list.size(); i < length; i++)
 
{...}

这样，在list.size()很大的时候，就减少了很多的消耗

补充:

用第一种方法时进行非空验证:

for (int i = 0; list!=null && i < list.size(); i++)
 
{...}

3.循环内不要不断创建对象引用

例如：

for (int i = 1; i <= count; i++)
 
{
 
    Object obj = new Object();    
 
}

这种做法会导致内存中有count份Object对象引用存在，count很大的话，就耗费内存了，建议为改为：

Object obj = null;
 
for (int i = 0; i <= count; i++)
 
{
 
    obj = new Object();
 
}

这样的话，内存中只有一份Object对象引用，每次new Object()的时候，Object对象引用指向不同的Object罢了，但是内存中只有一份，这样就大大节省了内存空间了。

4、尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销

5.字符串变量和字符串常量equals的时候将字符串常量写在前面

String str = "123";
 
if ("123".equals(str))
 
{
 
    ...
 
}

这么做主要是可以避免空指针异常

推荐荐使用 java.util.Objects#equals（JDK7 引入的工具类)，源码如下:

    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

6.任何数据在使用之前进行非空判断(包括对象，list)

        List<Employeeexam> employeeInExams = exam.getEmployeeInExams();
        List<Employeeexam> employeeOutExams = exam.getEmployeeOutExams();
        boolean insertEmployeeResult = false;
        int in_size, out_size;
        in_size = employeeInExams != null ? employeeInExams.size() : 0;
        out_size = employeeOutExams != null ? employeeOutExams.size() : 0;
        Integer employeeNum = in_size + out_size;

7.if...else...语句用条件运算符

return examMapper.deleteByPrimaryKey(id) > 0 ? true : false;

result = examService.deleteExamById(examId) ? "删除成功!" : "删除失败!";

8.善于使用commons-io包和commons-lang包中的工具类

　　io包中FilenameUtils和IOUtils和FileUtils的使用

　　lang包中  StringUtils和NumberUtils的使用等。

9.线程休眠的另一种方法

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

10. 对一些properties配置文件，我们可以在SVN或者Git放一个其样本文件，具体的文件不添加到版本管理，这样不会造成开发小组的冲突。

　　比如:db.properties文件，我们创建一个db.sample.properties(类似于模板)文件并传到git，db.properties文件不添加索引即可。

11. request对象可以当前文件在服务器的完整路径

request.getRealPath("/")

结果:

E:\xiangmu\SessionTest\WebContent\

12. 所有的相同类型的包装类对象之间值的比较，全部使用 equals 方法比较。

说明：对于 Integer var = ? 在-128 至 127 范围内的赋值，Integer 对象是在

IntegerCache.cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用==进行 判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑， 推荐使用 equals 方法进行判断。

 

13.  null可以强转为其他类型

String str = (String) null;

等价于

String str = null;

　　类型强转对应的指令是checkcast类型检查，如果检查失败会抛出类型转换异常ClassCastException

　　checkcast指令实际上和INSTANCEOF指令是很像的，不同的是CHECKCAST如果失败，会抛出一个异常，INSTANCEOF是返回一个值。

例如:

package cn.qlq;
 
public class Client {
 
    public static void main(String[] args) {
        Object object = null;
        String str = (String) object;
        System.out.println(str instanceof String);
    }
 
}

结果：

false

反编译查看字节码如下：

Compiled from "Client.java"
public class cn.qlq.Client {
  public cn.qlq.Client();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return
 
  public static void main(java.lang.String[]);
    Code:
       0: aconst_null
       1: astore_1
       2: aload_1
       3: checkcast     #16                 // class java/lang/String
       6: astore_2
       7: getstatic     #18                 // Field java/lang/System.out:Ljava/io/PrintStream;
      10: aload_2
      11: instanceof    #16                 // class java/lang/String
      14: invokevirtual #24                 // Method java/io/PrintStream.println:(Z)V
      17: return
}

14  重构方法

　　有时候我们用了一个方法为两个参数，现在如果需要改造该方法传入3个参数。

    private static void operate1(int i, int j) {
        // do something with i, j
    }

如果项目中太多地方用到两个参数的方法，如果直接改方法加入一个参数并不合适，可以重构一个方法，如下：将代码移到三个参数的，并在原来两个参数的方法中调用新方法，第三个参数传入null或者默认值。

    private static void operate1(int i, int j) {
        operate1(i, j, 0);
    }
 
    private static void operate1(int i, int j, int k) {
        // do something with i, j
 
        // do something with k
    }