java开发总结

1、字符串函数substring(beginIndex, endIndex):是冲beginIndex开始（包括beginIndex）,到endIndex（但不包括endIndex）。

 

2、字符串函数substring(beginIndex,beginIndex):取值为空。

例如String tempStr = "sdfsdf".substring(0,0); (tempStr的值为空"")。

 

3、Object tempObj = map.get("ss")，而map中并没有此key时，此句不会报异常(tempObj=null)

 

4、程序中写查询sql时，尽量不用*（select * from tableName），而是要吧查询的字段都写出来，因为根据数据的查询规则使用*进行查询时的效率要慢。（具体规则忘了）

 

5、在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 

 

1. import java.util.vector;  
2. class cel {  
3.     void method (vector vector) {  
4.         for (int i = 0; i < vector.size (); i++)  // violation  
5.             ; // ...  
6.     }  
7. }  

更正： 

1. class cel_fixed {  
2.     void method (vector vector) {  
3.         int size = vector.size ()  
4.         for (int i = 0; i < size; i++)  
5.             ; // ...  
6.     }  
7. }  

 

6、将try/catch块移出循环 

把try/catch块放入循环体内，会极大的影响性能，如果编译jit被关闭或者你所使用的是一个不带jit的jvm，性能会将下降21%之多! 

例子：         

 

1. import java.io.fileinputstream;  
2. public class try {  
3.     void method (fileinputstream fis) {  
4.         for (int i = 0; i < size; i++) {  
5.             try {                                      // violation  
6.                 _sum += fis.read();  
7.             } catch (exception e) {}  
8.         }  
9.     }  
10.     private int _sum;  
11. }  

 

 

import java.io.fileinputstream;
public class try {
    void method (fileinputstream fis) {
        for (int i = 0; i < size; i++) {
            try {                                      // violation
                _sum += fis.read();
            } catch (exception e) {}
        }
    }
    private int _sum;
}

   
更正：         
将try/catch块移出循环 

 

1. void method (fileinputstream fis) {  
2.        try {  
3.            for (int i = 0; i < size; i++) {  
4.                _sum += fis.read();  
5.            }  
6.        } catch (exception e) {}  
7.    }  

 

 

7、 不要在循环体中实例化变量  

在循环体中实例化临时变量将会增加内存消耗 

例子：  

1. import java.util.vector;  
2. public class loop {  
3.     void method (vector v) {  
4.         for (int i=0;i < v.size();i++) {  
5.             object o = new object();  
6.             o = v.elementat(i);  
7.         }  
8.     }  
9. }  

 

import java.util.vector;
public class loop {
    void method (vector v) {
        for (int i=0;i < v.size();i++) {
            object o = new object();
            o = v.elementat(i);
        }
    }
}

         
更正：         
在循环体外定义变量，并反复使用         

1. import java.util.vector;  
2. public class loop {  
3.     void method (vector v) {  
4.         object o;  
5.         for (int i=0;i<v.size();i++) {  
6.             o = v.elementat(i);  
7.         }  
8.     }  
9. }  

 

8、序列化（fastjson序列化get方法的执行）

        实体类中的非public、static属性都会被序列化。

        而序列化的过程中会自动调用属性的get方法（个人认为是取该属性的值进行序列化）：已验证

        反序列的过程中会自动调用属性的set方法（个人认为是为该对象的属性赋值）：未验证

      例如：序列化类Teacher object

   在执行JSON.toJSONString(object)此句中就会调用该对象属性的get方法，

	而序列化后该属性的值是get方法的返回值

 

public class Teacher {
        private int id;
        private List<Student> students;
        public BaseTestItemGroup() {
        }
        public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
        public List<Student> getStudents() {
		//在此可以加入一些逻辑处理，在序列的时候会自动执行（已验证）
		/*
		*逻辑处理代码（省略）
		*/	
		return students;
	}
	public void setStudents(List<Student> students) {
		//在此可以加入一些逻辑处理，在反序列的时候会自动执行（为验证）
		/*
		*逻辑处理代码（省略）
		*/
		this.students = students;}}

 

 

 

 

 

9、Hibernate session lazy

  所谓懒加载(lazy)就是延时加载，延迟加载。当两个及以上表使用hibernate来管理级联关系时，一个表（主表A）被加载到jvm内存时，其相关表(从表B)可以暂存在数据库的缓存中，当需要使用相关表(B)数据时再加载到jvm内存中，通过懒加载机制可以减少内存中不必要的开销，以提高程序的性能。

    需要注意的是，当使用懒加载时，如果将session关闭，则断开了与数据库的连接，此时如果要访问子表数据，由于子表数据是存放在数据库的缓存中，而连接已经关闭，则访问子表数据会抛出LazyInitializationException异常。

 

注意：当我们需要B表数据时，通过懒加载把B表的数据加载出来了，如果这时再关闭session，此时A表中的B表数据还是有的。因为你取出B时就已经把B表的数据赋给A了，而不需要在从session中查找关联关系，从库中取数据

 

 

10、SQL 查找是否存在，别再 count 了，很耗费时间！

业务代码中，需要根据一个或多个条件，查询是否存在记录，不关心有多少条记录。普遍的SQL及代码写法如下

#### SQL写法:
SELECT count(*) FROM table WHERE a = 1 AND b = 2

#### Java写法:
int nums = xxDao.countXxxxByXxx(params);
if ( nums > 0 ) {
  //当存在时，执行这里的代码
} else {
  //当不存在时，执行这里的代码
}

推荐写法如下：

#### SQL写法:
SELECT 1 FROM table WHERE a = 1 AND b = 2 LIMIT 1

#### Java写法:
Integer exist = xxDao.existXxxxByXxx(params);
if ( exist != NULL ) {
  //当存在时，执行这里的代码
} else {
  //当不存在时，执行这里的代码
}

SQL不再使用count，而是改用LIMIT 1，让数据库查询时遇到一条就返回，不要再继续查找还有多少条了

业务代码中直接判断是否非空即可