0.if嵌套的层数最好不要超过3层

 

  1. import java.util.HashMap;  
  2. import java.util.Map;  
  3.  
  4.  
  5. public class Qiantao {  
  6.       
  7.     /*  
  8.      * 嵌套太多层if,阅读性非常差，和看递归代码一样  
  9.      * @author yifangyou  
  10.      * @since 2011-08-16 09:35:00  
  11.      */ 
  12.     int example1(int a,String path,String account,String user){  
  13.         int result=0;  
  14.         if(account!=null){  
  15.             if(a==1){  
  16.                 if("/createAccount".equals(path)){  
  17.                     if(createAccount(account)){  
  18.                         result=1;  
  19.                     }else{  
  20.                         return -4;  
  21.                     }  
  22.                 }else if("/createUser".equals(path)){  
  23.                     if(isExistsAccount(account)){  
  24.                         if(createUser(account,user)){  
  25.                             result=2;  
  26.                         }else{  
  27.                             return -6;  
  28.                         }  
  29.                     }else{  
  30.                         return -5;  
  31.                     }  
  32.                 }else{  
  33.                     result=-3;  
  34.                 }  
  35.             }else{  
  36.                 result=-2;  
  37.             }  
  38.         }else{  
  39.             result=-1;  
  40.         }  
  41.           
  42.         return result;  
  43.     }  
  44.  
  45.     Map<String,Integer> paths=new HashMap<String,Integer>(){{  
  46.         this.put("/createAccount", 1);  
  47.         this.put("/createUser", 2);  
  48.     }};  
  49.       
  50.  
  51.     /*  
  52.      * 采用return减少嵌套层数,层次分明，便于修改，增加和删除判断比较容易  
  53.      * @author yifangyou  
  54.      * @since 2011-08-16 09:35:00  
  55.      */ 
  56.     int example2(int a,String path,String account,String user){  
  57.         if(account==null){  
  58.             return -1;  
  59.         }  
  60.           
  61.         if(a!=1){  
  62.             return -2;  
  63.         }  
  64.         Integer pathId=paths.get(path);  
  65.         if(pathId==null){  
  66.             return -3;  
  67.         }  
  68.         switch(pathId){  
  69.         case 1:  
  70.             if(!createAccount(account)){  
  71.                 return -4;  
  72.             }  
  73.             return 1;  
  74.         case 2:  
  75.             if(!isExistsAccount(account)){  
  76.                 return -5;  
  77.             }  
  78.             if(!createUser(account,user)){  
  79.                 return -6;  
  80.             }  
  81.             return 2;  
  82.         default:  
  83.             return 0;  
  84.         }  
  85.           
  86.     }  
  87.       
  88.     private boolean isExistsAccount(String account) {  
  89.         // TODO Auto-generated method stub  
  90.         return false;  
  91.     }  
  92.  
  93.     private boolean createUser(String account, String user) {  
  94.         // TODO Auto-generated method stub  
  95.         return false;  
  96.     }  
  97.  
  98.     private boolean createAccount(String account) {  
  99.         // TODO Auto-generated method stub  
  100.         return false;  
  101.     }  
  102. }  


  1.尽量重用数据库连接或者文件句柄
  2.过分的创建对象会消耗系统的大量内存，严重时，会导致内存泄漏，因此，保证过期的对象的及时回收具有重要意义。
    JVM的GC并非十分智能，因此建议在对象使用完毕后，手动设置成null。
  3.采用在需要的时候才开始创建的策略。
  4.array(数组)和ArrayList的使用。
    array 数组效率最高，但容量固定，无法动态改变，ArrayList容量可以动态增长，但牺牲了效率。 
  5.尽量使用基本数据类型代替对象。
  6.使用具体类比使用接口效率高，但结构弹性降低了
  7.读取配置文件内容，最好放在static变量里，不要用到时再解析配置文件
  8.避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量
  9.输入和输出(I/O)，避免多次读写同一个文件，读时最好尽量一次读取完需要的数据，写时，先把要写的内容全部放到变量里，一次写入文件
  10.数据库查询最好使用PrepStatement防止SQL注入,提高性能，prepStatement减少解析sql语句时间

 

  1. drop table IF EXISTS t1;  
  2.             create table t1(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));  
  3.             drop table IF EXISTS t2;  
  4.             create table t2(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));  
  5.             DROP PROCEDURE IF EXISTS test;  
  6.             DELIMITER ;;  
  7.             CREATE PROCEDURE test()  
  8.             BEGIN 
  9.                 truncate t1;  
  10.                 truncate t2;  
  11.                 set @start_time=UNIX_TIMESTAMP();  
  12.                 set @id=1;  
  13.                 SET @sql_str = "insert into t1 values(?,'a')";  
  14.                     PREPARE stmt FROM @sql_str;  
  15.                 REPEAT  
  16.                      EXECUTE stmt USING @id;  
  17.                      set @id=@id+1;  
  18.                 UNTIL @id>100000 END REPEAT;  
  19.                 DEALLOCATE PREPARE stmt;      
  20.                 select UNIX_TIMESTAMP()-@start_time as span;  
  21.                 set @start_time=UNIX_TIMESTAMP();  
  22.                 set @id=1;    
  23.                 REPEAT  
  24.                      insert into t2 values(@id,'a');  
  25.                      set @id=@id+1;  
  26.                 UNTIL @id>100000 END REPEAT;     
  27.                 select UNIX_TIMESTAMP()-@start_time as span;  
  28.             END;;  
  29.             DELIMITER ;  
  30.         call test(); 

11.能够在数据库里做的操作，尽量在数据库里做，因为数据是集合运算
12.带索引的inner join 比in效率高得多

 

  1. select count(*) from region;  
  2.            select count(*) from cidr;  
  3.            select SQL_NO_CACHE count(*) from cidr where region_id in(select id from region);  
  4.            select SQL_NO_CACHE count(*) from cidr inner join region on cidr.region_id=region.id; 

13.经常查询的字段加上索引，这个能够提高20倍
14. 当只要一行数据时使用 LIMIT 1，这样mysql查询到1条后可以马上返回结果；
15.避免 SELECT *,查询哪个字段就写哪个，这样可以减少查询时间和网络传输；
16. 拆分大的 DELETE 或 INSERT 语句
        如果你需要在一个在线的网站上去执行一个大的 DELETE 或 INSERT 查询，你需要非常小心，要避免你的操作让你的整个网站停止相应。
        因为这两个操作是会锁表的，表一锁住了，别的操作都进不来了。
17.隐式提交

在事务执行过程中，执行下面语句相当于执行COMMIT

 

  1. ALTER FUNCTION, ALTER PROCEDURE, ALTER TABLE, BEGIN, CREATE DATABASE, CREATE FUNCTION, CREATE INDEX, CREATE PROCEDURE, CREATE TABLE, DROP DATABASE, DROP FUNCTION, DROP INDEX, DROP PROCEDURE, DROP TABLE, LOAD MASTER DATA, LOCK TABLES, RENAME TABLE, SET AUTOCOMMIT=1, START TRANSACTION, TRUNCATE TABLE, UNLOCK TABLES. 

truncate 或者drop临时表会引起隐式提交

CREATE TEMPORARY TABLE 临时表不会引起隐式提交

delete from 临时表不会引起隐式提交

CREATE VIEW 会引起隐式提交

18.事务并行问题，按照谁先执行事务的顺序生效
     两个事务同时delete,update,insert操作同一行时，或者含有自增id时会引起挂起

  1. create table t(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));    
  2. create table t(id int NOT NULL,name varchar(10));     
  3. --客户端A    
  4. SET AUTOCOMMIT =0;    
  5. insert into t values (1,'a');    
  6. --客户端 B    
  7. SET AUTOCOMMIT =0;    
  8. insert into t values (1,'b');                 
  9. ----------------------------------------  
  10. --客户端A    
  11. SET AUTOCOMMIT =0;    
  12. insert into t values (2,'a');    
  13. --客户端 B    
  14. SET AUTOCOMMIT =0;    
  15. delete from t where id=2;      
  16. --或者    
  17. update t set name='c' where id=2;                                   
  18. ----------------------------------------  
  19. --客户端A    
  20. SET AUTOCOMMIT =0;    
  21. delete from t where id=2;    
  22. --客户端 B    
  23. SET AUTOCOMMIT =0;    
  24. update t set name='c' where id=2;    
  25. --或者         
  26. delete from t where id=2;