java代码大全(java常用代码大全)

导读

世界上只有两种物质:高效和低效；世界上只有两种人:高效率的人和低效率的人。——萧伯纳

同样，世界上只有两种代码:高效代码和低效代码；世界上只有两种人:写高效代码的人和写低效代码的人。如何编写高效的代码是每个R&D团队面临的主要问题。因此，笔者根据实践经验，查阅了大量资料，总结出& # 34；50例Java高效代码& # 34；，让每个Java程序员都能写& # 34；高效代码& # 34；。

1.常量&变量1.1.直接赋值常量值，禁止声明新对象

直接分配一个常数值只会创建一个指向常数值的对象引用。

反例:

龙i =新龙(1L)；String s =新字符串(& # 34；abc & # 34);示例:

龙I = 1L；字符串s = & # 34abc & # 34；1.2.当成员变量的值不需要改变时，尽量将其定义为静态常量。在类的每个对象实例中，每个成员变量都有一个副本，而成员静态常量只有一个实例。

反例:

public类http connection { private final long time out = 5L；...}正面例子:

public类http connection { private static final long time out = 5L；...}1.3.尽量使用基本数据类型，避免Java中基本数据类型double、float、long、int、short、char、boolean的自动打包和解包，分别对应打包类Double、Float、Long、Integer、Short、Character、Boolean。JVM支持基本类型和相应包装类之间的自动转换，称为自动打包和解包。打包和解包需要占用CPU和内存资源，所以要尽量避免自动打包和解包。

反例:

整数和= 0；int[]值=...；for(int value:values){ sum+= value；//相当于result = integer . value of(result . int value()+value)；}正面例子:

int sum = 0；int[]值=...；for(int value:values){ sum+= value；}1.4.如果变量的初始值将被覆盖，则不需要为变量分配初始值，作为反例:

列表& ltUserDO & gtuserList = new ArrayList & lt& gt();if(is all){ userList = userdao . query all()；} else { userList = userdao . query active()；}正面例子:

列表& ltUserDO & gt用户列表；if(is all){ userList = userdao . query all()；} else { userList = userdao . query active()；}1.5.尽量在函数中使用基本类型的临时变量。基本类型参数和临时变量存储在堆栈中，访问速度更快；对象的参数和临时变量的引用存储在栈中，内容存储在堆中，所以访问速度慢。在类中，任何类型的成员变量都存储在堆中，访问速度很慢。

反例:

公共final类累加器{私有double result = 0.0Dpublic void addAll(@ NonNull double[]values){ for(double value:values){ result+= value；}} ...}正面例子:

公共final类累加器{私有double result = 0.0Dpublic void addAll(@ NonNull double[]values){ double sum = 0.0D；for(double value:values){ sum+= value；}结果+=总和；} ...}1.6.尽量不要在循环之外定义变量。在旧版的JDK中，建议“尽量不要在循环内部定义变量”，但在新版的JDK中已经进行了优化。通过对编译后字节码的分析，循环外和循环内的变量定义没有本质区别，运行效率基本相同。相反，根据“最小化局部变量范围”的原则，循环中变量的定义更加科学，也更容易维护，从而避免了因延长大型对象的生命周期而导致的延迟回收的问题。

反例:

UserVO userVO列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(user do user do:user dolist){ user VO = new user VO()；user VO . setid(user do . getid())；...user volist . add(user VO)；}正面例子:

列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(user do user do:user dolist){ user VO user VO = new user VO()；user VO . setid(user do . getid())；...user volist . add(user VO)；}1.7.不可变的静态常量。尽量使用非线程安全类的不可变静态常量。虽然支持多线程访问是必要的，但是也可以使用非线程安全的类。

反例:

公共静态最终地图& ltString，Class & gtCLASS _ MAP静态{ Map & ltString，Class & gtclass map = new concurrent hashmap & lt；& gt(16);class map . put(& # 34；VARCHAR & # 34，Java . lang . string . class)；...CLASS _ MAP = collections . unmodifiablemap(CLASS MAP)；}正面例子:

公共静态最终地图& ltString，Class & gtCLASS _ MAP静态{ Map & ltString，Class & gtclassMap = new HashMap & lt& gt(16);class map . put(& # 34；VARCHAR & # 34，Java . lang . string . class)；...CLASS _ MAP = collections . unmodifiablemap(CLASS MAP)；}1.8.不可变成员变量。尽量使用非线程安全类的不可变成员变量。虽然支持多线程访问是必要的，但是也可以使用非线程安全的类。

反例:

@Servicepublic类StrategyFactory实现initializing bean { @ auto wired private List & lt；策略& gt战略列表；私人地图& lt字符串，策略& gt战略地图；@ Override public void afterPropertiesSet(){ if(collection utils . isnotempty(strategy list)){ int size =(int)math . ceil(strategy list . size()* 4.0/3)；地图& lt字符串，策略& gtmap = new ConcurrentHashMap & lt& gt(大小)；for(Strategy Strategy:Strategy list){ map . put(Strategy . gettype()，Strategy)；} strategy map = collections . unmodifablemap(map)；}} ...}正面例子:

@Servicepublic类StrategyFactory实现initializing bean { @ auto wired private List & lt；策略& gt战略列表；私人地图& lt字符串，策略& gt战略地图；@ Override public void afterPropertiesSet(){ if(collection utils . isnotempty(strategy list)){ int size =(int)math . ceil(strategy list . size()* 4.0/3)；地图& lt字符串，策略& gtmap = new HashMap & lt& gt(大小)；for(Strategy Strategy:Strategy list){ map . put(Strategy . gettype()，Strategy)；} strategy map = collections . unmodifablemap(map)；}} ...}2.对象和类2.1。禁止使用JSON转换对象。JSON提供了将对象转换成JSON字符串，将JSON字符串转换成对象的功能，所以被一些人用来转换对象。虽然功能上没有问题，但是这种对象转换方式在性能上有问题。

反例:

列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuser volist = JSON . parse array(JSON . tojsonstring(user dolist)，user VO . class)；示例:

列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(user do user do:user dolist){ user VO user VO = new user VO()；user VO . setid(user do . getid())；...user volist . add(user VO)；}2.2.尽量不要使用反射性的赋值对象。主要优点是节省代码量，主要缺点是性能下降。

反例:

列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(user do user do:user dolist){ user VO user VO = new user VO()；bean utils . copy properties(user do，user VO)；user volist . add(user VO)；}正面例子:

列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(user do user do:user dolist){ user VO user VO = new user VO()；user VO . setid(user do . getid())；...user volist . add(user VO)；}2.3.用Lambda表达式替换内部匿名类对于大部分刚接触JDK8的同学来说，他们会认为Lambda表达式是匿名内部类的语法糖。实际上，Lambda表达式在大多数虚拟机中都是通过invokeDynamic指令实现的，比匿名内部类效率更高。

反例:

列表& lt用户& gt用户列表=...；Collections.sort(用户列表，新比较器& lt用户& gt(){ @ Override public int compare(User User 1，User User 2){ Long userid 1 = User 1 . getid()；long userid 2 = user 2 . getid()；...返回userid 1 . compare to(userid 2)；}});示例:

列表& lt用户& gt用户列表=...；Collections.sort(用户列表，(用户1，用户2)-& gt；{ Long userid 1 = user 1 . getid()；long userid 2 = user 2 . getid()；...返回userid 1 . compare to(userid 2)；});2.4.尽量避免定义不必要的子类。多一个类就需要多一个类加载，所以尽量避免定义不必要的子类。

反例:

公共静态最终地图& ltString，Class & gtCLASS _ MAP = collections . unmodifiablemap(new HashMap & lt；String，Class & gt(16){ private static final long serialVersionUID = 1L；{放(& # 34；VARCHAR & # 34，Java . lang . string . class)；}});示例:

公共静态最终地图& ltString，Class & gtCLASS _ MAP静态{ Map & ltString，Class & gtclassMap = new HashMap & lt& gt(16);class map . put(& # 34；VARCHAR & # 34，Java . lang . string . class)；...CLASS _ MAP = collections . unmodifiablemap(CLASS MAP)；}2.5.尝试指定类的最后一个修饰符。为类指定final修饰符会使该类无法被继承。如果一个类被指定为final，那么该类的所有方法都是final，Java编译器将寻找机会内联所有final方法。内联在提高Java运行效率方面起着重要的作用。详见Java运行时优化，平均可以提升50%的性能。

反例:

课程日期助手{...}正面例子:

公共类日期助手{...}注意:使用Spring的AOP特性时，需要动态代理Bean。如果Bean类用final修饰，就会导致异常。

3.方法3.1.把跟类成员变量无关的方法声明成静态方法

静态方法的优点是可以直接调用它们，而无需生成类的实例。静态方法不再属于一个对象，而是属于它所在的类。只能通过类名访问，不需要消耗资源重复创建对象。即使是类中的私有方法，如果不使用类成员变量，也应该声明为静态方法。

反例:

public int getMonth(Date Date){ Calendar Calendar = Calendar . getinstance()；calendar.setTime(日期)；返回calendar.get(Calendar。月)+1；}正面例子:

public static int getMonth(Date Date){ Calendar Calendar = Calendar . getinstance()；calendar.setTime(日期)；返回calendar.get(Calendar。月)+1；}3.2.尽量使用基本数据类型作为方法参数类型，避免不必要的打包、解包和空指针判断作为反例:

public static Double sum(Double value 1，Double value 2){ Double Double 1 = objects . is null(value 1)？0.0D:值1；double double 2 = objects . is null(value 2)？0.0D:值2；返回double 1+double 2；}double result = sum(1.0D，2.0D)；示例:

公共静态double sum(double value1，double value 2){ return value 1+value 2；}double result = sum(1.0D，2.0D)；3.3.尽量使用基本数据类型作为方法返回值类型，避免不必要的装箱、拆箱和空指针判断。在JDK类库的方法中，很多方法返回值采用基本数据类型，首先是为了避免不必要的装箱和拆箱，其次是为了避免返回值的空指针判断。例如:Collection.isEmpty()和Map.size()。

反例:

public static Boolean is valid(UserDO user){ if(objects . is null(user)){ return false；}返回布尔值。true . equals(user . getis valid())；}//调用代码UserDO user =...；Boolean isValid = isValid(用户)；if(objects . nonnull(is valid)& & is valid . boolean value()){...}正面例子:

public static boolean is valid(UserDO user){ if(objects . is null(user)){ return false；}返回布尔值。true . equals(user . getis valid())；}//调用代码UserDO user =...；If (isValid(user)) {...}3.4.协议方法的参数值不是空，避免了不必要的空指针判断协议编程。可以用@NonNull和@Nullable来标记参数，要不要遵循就看调用者的意识了。

反例:

public static boolean is valid(UserDO user){ if(objects . is null(user)){ return false；}返回布尔值。true . equals(user . getis valid())；}正面例子:

public static Boolean is valid(@ NonNull user do user){ return Boolean。true . equals(user . getis valid())；}3.5.协议方法的返回值不是空。避免不必要的空指针来判断协议编程。可以用@NonNull和@Nullable标记参数。是否遵循，取决于实施者的自觉。

反例:

//定义接口公共接口orderservice { public list < order VO & gt；queryUserOrder(长userId)；}//调用代码列表order list = orderservice . queryuseorder(userId)；If(集合utils。不为空(订单列表)){for(订单:订单列表){...}}正面例子:

//定义接口公共接口orderservice { @ nonnull public list < order VO & gt；queryUserOrder(长userId)；}//调用代码列表order list = orderservice . queryuseorder(userId)；For (order voorder:订单列表){...} 3.6.被调用的方法已经支持判断空处理，调用方法不需要再次进行判断空处理。反例:

UserDO user = nullif(string utils . isnotblank(value)){ user = JSON . parse object(value，userdo . class)；}正面例子:

UserDO user = JSON . parse object(value，UserDO . class)；3.7.尽量避免不必要的函数封装方法调用，这样会造成推入和推出，造成更多的CPU和内存消耗。应尽可能避免不必要的函数封装。当然，为了让代码更简洁、更清晰、更易于维护，增加某些方法调用带来的性能损失是值得的。

反例:

//函数封装公共静态boolean is VIP(boolean is VIP){ return boolean . true . equals(is VIP)；}//使用代码boolean isVip = isVip(user . get VIP())；示例:

布尔型isVip =布尔型。true . equals(user . get VIP())；3.8.尝试指定方法的最终修饰符。方法指定最后一个修饰符，因此无法重写该方法。Java编译器将寻找内联所有最终方法的机会。内联在提高Java运行效率方面起着重要的作用。详见Java运行时优化，平均可以提升50%的性能。

注意:所有私有方法都被隐式地分配了final修饰符，所以没有必要给它们分配final修饰符。

反例:

公共矩形{...公共double area () {...}}正面例子:

公共矩形{...公共最终double area () {...}}注意:使用Spring的AOP特性时，需要动态代理Bean。如果该方法用final修饰，它将不会被代理。

4.表达式4.1.尽量减少方法的重复调用

反例:

列表& ltUserDO & gt用户列表=...；for(int I = 0；我& ltuser list . size()；++) {...}正面例子:

列表& ltUserDO & gt用户列表=...；int user length = userlist . size()；for(int I = 0；我& ltuserLength+i++) {...}4.2.作为反例，尽量避免不必要的方法调用:

列表& ltUserDO & gtuserList = userdao . query active()；if(is all){ userList = userdao . query all()；}正面例子:

列表& ltUserDO & gt用户列表；if(is all){ userList = userdao . query all()；} else { userList = userdao . query active()；}4.3.尽量用移位代替正整数的乘除。使用移位操作可以大大提高性能。对于2 n (n为正整数)乘除正整数的计算，可以用移位运算代替。

反例:

int num 1 = a * 4；int num 2 = a/4；示例:

int num1 = a & lt& lt2;int num2 = a & gt& gt2;4.4.提取公共表达式，避免重复计算，提取公共表达式，只计算一次值，然后重用值。

反例:

双距离= math . sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1))；示例:

double dx = x2-x1；double dy = y2-y1；double distance = math . sqrt(dx * dx+dy * dy)；或者双距离= math.sqrt (math.power (x2-x1，2)+math.power (y2-y1，2))；4.5.尽量不要在条件表达式中使用！反向使用！反算会再做一次，不需要的话会优化。

反例:

如果(！(a & gt= 10)) {...//条件处理1}否则{...//条件处理2}正例:

如果(a & lt10) {...//条件处理1}否则{...//条件处理2}4.6。对于多常量选择分支，尽量使用switch语句，而不是if-else语句if-else语句。每个if条件语句都应该被额外计算，直到if条件语句为真。switch语句通过跳转进行优化，在Java中通过tableswitch或lookupswitch指令实现，对于选择多个常量的分支效率更高。实验表明，if-else语句在每个分支的概率相同时效率更高，switch语句在低于5个分支时效率更高。

反例:

if (i == 1) {...；//branch 1} else if (i == 2) {...；//branch 2} else if (i ==...) {...；//branch n} else {...；//分支n+1}正例:

开关(I){情况1:...//分支1中断；2:案例...//分支2断开；情况...：...//branch n break；默认值:...//分支n+1 break；}备注:如果业务复杂，可以采用Map实现策略模式。

5.字符串5.1.尽量不要使用正则表达式匹配

正则表达式匹配效率低，尽量用字符串匹配。

反例:

字符串源= & # 34；a::1，b::2，c::3，d::4 & # 34；；string target = source . replace all(& # 34；::", "=");stringp[]targets = source . spit(& # 34；::");示例:

字符串源= & # 34；a::1，b::2，c::3，d::4 & # 34；；string target = source . replace(& # 34；::", "=");stringp[]targets = string utils . split(source，& # 34；::");5.2.尝试用字符替换字符串。字符串的长度是不确定的，而字符的长度固定为1，搜索匹配的效率自然提高。

反例:

字符串源= & # 34；甲:1，乙:2，丙:3，丁:4 & # 34；；int index = source . index of(& # 34；:");string target = source . replace(& # 34；:", "=");示例:

字符串源= & # 34；甲:1，乙:2，丙:3，丁:4 & # 34；；int index = source . index of(& # 39；:');string target = source . replace(& # 39；:', '=');5.3.尽量使用StringBuilder进行字符串拼接。String是final类，其内容不可修改，所以每次字符串拼接都会生成一个新的对象。StringBuilder在初始化时申请了一块内存，以后所有的字符串拼接都将在这块内存中进行，不需要申请新的内存和生成新的对象。

反例:

字符串s = & # 34"；for(int I = 0；我& lt10;i++) { if (i！= 0){ s+= & # 39；,'；} s+= I；}正面例子:

StringBuilder sb = new StringBuilder(128)；for(int I = 0；我& lt10;i++) { if (i！= 0){ sb . append(& # 39；,');} sb.append(一)；}5.4.不要使用& # 34；"+使用& # 34；"+字符串转换，好用但效率低，推荐用String.valueOf。

反例:

int i = 12345字符串s = & # 34"+I；示例:

int i = 12345string s = string . value of(I)；6.数组6.1。不要使用循环复制数组，尽量使用System.arraycopy数组。建议使用System.arraycopy array或Arrays.copyOf array。

反例:

int[] sources = new int[] {1，2，3，4，5 }；int[]targets = new int[sources . length]；for(int I = 0；我& lt目标.长度；i++){ targets[I]= sources[I]；}正面例子:

int[] sources = new int[] {1，2，3，4，5 }；int[]targets = new int[sources . length]；System.arraycopy(源，0，目标，0，目标.长度)；6.2.当一个集合被转换为T类型数组时，尝试传入空数组T[0]。将集合转换为数组有两种形式:toArray(new T[n])和toArray(new T[0])。在旧的Java版本中，建议使用toArray(new T[n])，因为创建数组所需的反射调用非常慢。打开JDK 6后，反射调用是固有的，提高了性能。toArray(new T[0])比toArray(new T[n])更高效。另外，toArray(new T[n])获得列表大小的次数比toArray(new T[0])多一次，如果计算列表大小的时间太长，toArray(new T[n])的效率也会降低。

反例:

列表& lt整数& gtintegerList = Arrays.asList(1，2，3，4，5，...);Integer[]integers = Integer list . to array(new Integer[Integer list . size()])；示例:

列表& lt整数& gtintegerList = Arrays.asList(1，2，3，4，5，...);Integer[]integers = Integer list . to array(new Integer[0])；//不要使用new Integer[]{}建议:集合应该提供一个to array(class < T & gt；Clazz)方法避免无用的空数组初始化(新T[0])。

6.3.集合转化为Object数组时，尽量使用toArray()方法

转换对象数组时不需要使用toArray [newObject [0]]，可以直接使用toArray()。避免了类型判断，也避免了空数组的应用，所以效率会更高。

反例:

列表& ltObject & gtobjectList = Arrays.asList(1，& # 34；2", 3, "4", 5, ...);Object[]objects = Object list . to array(new Object[0])；示例:

列表& ltObject & gtobjectList = Arrays.asList(1，& # 34；2", 3, "4", 5, ...);object[]objects = object list . to array()；7.设置7.1。初始化集合时，尝试指定集合大小。Java集合在初始化时会指定一个默认大小。当默认大小不再满足数据要求时，它将被扩展。每次扩展的时间复杂度可以是O(n)。因此，通过尽可能指定预测的集合大小，可以避免或减少集合的扩展时间。

反例:

列表& ltUserDO & gt用户列表=...；设置& ltLong & gtuserSet = new HashSet & lt& gt();地图& ltLong，UserDO & gtuserMap = new HashMap & lt& gt();列表& ltUserVO & gtuserList = new ArrayList & lt& gt();for(UserDO UserDO:userDOList){ userset . add(UserDO . getid())；userMap.put(userDO.getId()，userDO)；userlist . add(transUser(userDO))；}正面例子:

列表& ltUserDO & gt用户列表=...；int userSize = user dolist . size()；设置& ltLong & gtuserSet = new HashSet & lt& gt(userSize)；地图& ltLong，UserDO & gtuserMap = new HashMap & lt& gt((int)math . ceil(userSize * 4.0/3))；列表& ltUserVO & gtuserList = new ArrayList & lt& gt(userSize)；for(UserDO UserDO:userDOList){ userset . add(UserDO . getid())；userMap.put(userDO.getId()，userDO)；userlist . add(transUser(userDO))；}7.2.不要循环复制集合，尝试使用JDK提供的方法复制集合。JDK提供的方法可以一步指定集合的容量，避免多次扩展浪费时间和空。同时，这些方法的底层也是通过调用System.arraycopy方法来实现的，使得批量复制数据的效率更高。

反例:

列表& ltUserDO & gt用户1列表=...；列表& ltUserDO & gt用户2列表=...；列表& ltUserDO & gtuserList = new ArrayList & lt& gt(user 1 list . size()+user 2 list . size())；for(UserDO user 1:user 1 list){ userlist . add(user 1)；} for(UserDO user 2:user 2 list){ userlist . add(user 2)；}正面例子:

列表& ltUserDO & gt用户1列表=...；列表& ltUserDO & gt用户2列表=...；列表& ltUserDO & gtuserList = new ArrayList & lt& gt(user 1 list . size()+user 2 list . size())；userlist . addall(user 1 list)；userlist . addall(user 2 list)；7.3.尝试使用Arrays.asList将数组转换为列表。原理和& # 34；不要循环复制集合，尽量使用JDK提供的方法复制集合& # 34；类似。

反例:

列表& lt字符串& gttypeList = new ArrayList & lt& gt(8);type list . add(& # 34；Short & # 34);type list . add(& # 34；整数& # 34；);type list . add(& # 34；龙& # 34；);字符串[]名称=...；列表& lt字符串& gt名称列表=...；for(String name:names){ name list . add(name)；}正面例子:

列表& lt字符串& gttypeList = arrays . aslist(& # 34；Short & # 34, "整数& # 34；, "龙& # 34；);字符串[]名称=...；列表& lt字符串& gt名称列表=...；name list . addall(arrays . as list(names))；7.4.直接迭代要使用的集合。直接迭代要使用的集合，不需要通过其他操作获取数据。

反例:

地图& ltLong，UserDO & gt用户地图=...；for(Long userId:user map . keyset()){ UserDO user = user map . get(userId)；...}正面例子:

地图& ltLong，UserDO & gt用户地图=...；对于(图。Entry & ltLong，UserDO & gtuser entry:user map . entry set()){ Long userId = user entry . getkey()；UserDO user = user entry . getvalue()；...}7.5.不要用size方法检测空，必须用isEmpty方法检测空。使用size方法检测空没有逻辑问题，但是使用isEmpty方法使得代码可读性更好，可以获得更好的性能。任何isEmpty方法的时间复杂度都是O(1)，但某些size方法的时间复杂度可能是O(n)。

反例:

列表& ltUserDO & gt用户列表=...；if (userList.size() == 0) {...}地图& ltLong，UserDO & gt用户地图=...；If (userMap.size() == 0) {...}正面例子:

列表& ltUserDO & gt用户列表=...；if (userList.isEmpty()) {...}地图& ltLong，UserDO & gt用户地图=...；If (userMap.isEmpty()) {...}7.6.用非RandomAccess列表，尽量用迭代代替随机访问。对于列表，可以分为随机访问和非随机访问，可以通过随机访问接口是否实现来判断。随机访问列表，直接通过get获取数据不影响效率。而不是随机访问列表，通过get获取数据效率极低。

反例:

LinkedList & ltUserDO & gt用户列表=...；int size = userdolist . size()；for(int I = 0；我& lt尺寸；i++){ UserDO UserDO = userdolist . get(I)；...}正面例子:

LinkedList & ltUserDO & gt用户列表=...；For (userdo userdo: userdolist) {...}其实不管列表分支是否支持随机访问，都应该迭代。

7.7.尽量使用HashSet判断值存在

在Java集合类库中，List的contains方法的时间复杂度一般为O(n)，而HashSet的时间复杂度为O(1)。如果需要经常调用contains方法来查找数据，可以先将List转换成HashSet。

反例:

列表& ltLong & gtadminIdList =...；列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(UserDO UserDO:userDOList){ if(adminidlist . contains(UserDO . getid()){ uservolist . add(trans user(UserDO))；}}正面例子:

设置& ltLong & gtadminIdSet =...；列表& ltUserDO & gt用户列表=...；列表& ltUserVO & gtuserVOList = new ArrayList & lt& gt(userdolist . size())；for(UserDO UserDO:userDOList){ if(adminid set . contains(UserDO . getid()){ uservolist . add(trans user(UserDO))；}}7.8.避免在获得之前判断存在。如果在获取之前需要判断存在，可以直接获取并判断空，从而避免第二次搜索操作。

反例:

公共静态UserVO transUser(UserDO用户，Map & ltLong，RoleDO & gtrole map){ user VO user VO = new user VO()；user VO . setid(user . getid())；...if(role map . contains(user . getroleid()){ RoleDO role = role map . get(user . getroleid())；user VO . set role(trans role(role))；}}正面例子:

公共静态UserVO transUser(UserDO用户，Map & ltLong，RoleDO & gtrole map){ user VO user VO = new user VO()；user VO . setid(user . getid())；...RoleDO role = role map . get(user . getroleid())；if(objects . nonnull(role)){ user VO . set role(trans role(role))；}}8.例外8.1。直接捕捉对应的异常，避免通过instanceof判断，代码更加高效简洁。

反例:

请尝试{ saveData()；} catch(Exception e){ if(e instance of io Exception){ log . error(& # 34；保存数据io时出现异常& # 34；，e)；} else { log . error(& # 34；保存数据时的其他异常& # 34；，e)；}}正面例子:

请尝试{ saveData()；} catch(io exception e){ log . error(& # 34；保存数据io时出现异常& # 34；，e)；} catch(Exception e){ log . error(& # 34；保存数据时的其他异常& # 34；，e)；}8.2.尽量避免在循环中捕捉异常。当循环体抛出异常时，当循环不需要继续执行时，没有必要在循环体中捕捉异常。因为异常太多会降低程序执行的效率。

反例:

公共双和(列表& lt字符串& gtvalue list){ double sum = 0.0D；for(String value:valueList){ try { sum+= double . parse double(value)；} catch(NumberFormatException e){ return null；} }返回sum}正面例子:

公共双和(列表& lt字符串& gtvalue list){ double sum = 0.0D；try { for(String value:valueList){ sum+= double . parse double(value)；} } catch(NumberFormatException e){ return null；}返回sum}8.3.禁止使用异常来控制业务流程。与条件表达式相比，异常处理效率较低。

反例:

public static Boolean is valid(UserDO user){ try { return Boolean。true . equals(user . getis valid())；} catch(NullPointerException e){ return false；}}正面例子:

public static boolean is valid(UserDO user){ if(objects . is null(user)){ return false；}返回布尔值。true . equals(user . getis valid())；}9.缓冲器9.1。初始化时，尽可能指定缓冲区大小。初始化时，指定缓冲区的预期容量，以避免多次扩展浪费时间和空。

反例:

string buffer buffer = new string buffer()；StringBuilder builder = new StringBuilder()；示例:

string buffer buffer = new string buffer(1024)；StringBuilder builder = new StringBuilder(1024)；9.2.尽可能重复使用同一个缓冲区。对于缓冲区，Java虚拟机需要花时间生成对象，也需要花时间进行垃圾收集。因此，尽量重复使用缓冲区。

反例:

StringBuilder builder 1 = new StringBuilder(128)；builder 1 . append(& # 34；update t _ user set name = & # 39").追加(用户名)。追加(& # 34；'其中id = & # 34).append(userId)；statement . execute update(builder 1 . tostring())；StringBuilder builder 2 = new StringBuilder(128)；builder 2 . append(& # 34；select id，name from t_user其中id = & # 34).append(userId)；ResultSet resultSet =语句. execute query(builder 2 . tostring())；...正面例子:

StringBuilder builder = new StringBuilder(128)；builder . append(& # 34；update t _ user set name = & # 39").追加(用户名)。追加(& # 34；'其中id = & # 34).append(userId)；statement . execute update(builder . tostring())；builder . setlength(0)；builder . append(& # 34；select id，name from t_user其中id = & # 34).append(userId)；ResultSet resultSet =语句. execute query(builder . tostring())；...其中setLength方法用于从0重新启动缓冲区。

9.3.尽量设计使用同一缓冲区

为了提高程序的运行效率，在设计中尽量使用相同的缓冲区。

反例:

//将XML (userdo)公共静态字符串转换为XML(user douser){ string builder = newstring builder(128)；builder . append(& # 34；& ltUserDO & gt");builder . append(to XML(user . getid()))；builder . append(to XML(user . getname()))；builder . append(to XML(user . getrole()))；builder . append(& # 34；& lt/UserDO & gt；");返回builder . tostring()；}//将XML (long)公共静态字符串转换为XML(long value){ stringbuilder = new stringbuilder(128)；builder . append(& # 34；& ltLong & gt");builder.append(值)；builder . append(& # 34；& lt/Long & gt；");返回builder . tostring()；} ...//使用代码UserDO user =...；String xml = toXml(用户)；示例:

//将XML (userdo) public static void转换为XML (stringbuilder，user douser){ builder . append(& # 34；& ltUserDO & gt");toXml(builder，user . getid())；toXml(builder，user . getname())；toXml(builder，user . getrole())；builder . append(& # 34；& lt/UserDO & gt；");}//将XML (long) public static void转换为XML (stringbuilder，long value){ builder . append(& # 34；& ltLong & gt");builder.append(值)；builder . append(& # 34；& lt/Long & gt；");} ...//使用代码UserDO user =...；StringBuilder builder = new StringBuilder(1024)；toXml(构建者，使用者)；string XML = builder . tostring()；删除每个转换方法中的缓冲区应用程序，并为每个转换方法申请一个缓冲区。时间上，节省了大量缓冲区的应用发布时间；从空室，节省了大量的暂存空室的缓冲区。

9.4.尽量使用缓冲流减少IO操作

使用缓冲流BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream等。可以大大减少IO次数，提高IO速度。

反例:

try(file inputstream input = new file inputstream(& # 34；一& # 34；);file output stream output = new file output stream(& # 34；b & # 34)){ int size = 0；byte[] temp =新字节[1024]；while ((size = input.read(temp))！= -1) { output.write(temp，0，size)；} } catch(io exception e){ log . error(& # 34；复制文件时出现异常& # 34；，e)；}正面例子:

try(BufferedInputStream input = new BufferedInputStream(new file inputstream(& # 34；一& # 34；));BufferedOutputStream output = new BufferedOutputStream(new file output stream(& # 34；b & # 34))){ int size = 0；byte[] temp =新字节[1024]；while ((size = input.read(temp))！= -1) { output.write(temp，0，size)；} } catch(io exception e){ log . error(& # 34；复制文件时出现异常& # 34；，e)；}其中，可以根据实际情况手动指定缓冲流的大小，最大化缓冲流的缓冲效果。

10.线程10.1.在单线程中，尽量使用非线程安全类

使用非线程安全的类可以避免不必要的同步开销。

反例:

string buffer buffer = new string buffer(128)；buffer . append(& # 34；select * from & # 34).append(T_USER)。追加(& # 34；其中id =？");示例:

StringBuilder buffer = new StringBuilder(128)；buffer . append(& # 34；select * from & # 34).append(T_USER)。追加(& # 34；其中id =？");0.2.多线程中，尽量使用线程安全类，比自己实现的同步代码更简洁高效。

反例:

private volatile int计数器= 0；public void access(Long userId){ synchronized(this){ counter++；} ...}正面例子:

private final atomic integer counter = new atomic integer(0)；public void access(Long userId){ counter . incrementandget()；..}10.3.最小化同步代码块的范围。在一个方法中，可能只有一小部分逻辑需要同步，如果整个方法都同步，会影响执行效率。所以尽量缩小同步代码块的范围，只同步需要同步的代码。

反例:

private volatile int计数器= 0；公共同步void访问(长userId){ counter++；...//异步操作}正例:

private volatile int计数器= 0；public void access(Long userId){ synchronized(this){ counter++；} ...//异步操作}10.4。尝试合并到同一个同步代码块中会有性能开销。如果确定可以合并到同一个同步码块中，就尽可能合并到同一个同步码块中。

反例:

//处理单一订单公共同步处理订单(orderdo order) {...}//处理所有订单公共void handle order(List & lt < OrderDO & gt；order list){ for(order do order:order list){ handle order(order)；}}正面例子:

//处理单一订单公共处理订单(orderdo order) {...}//处理所有订单公共同步void句柄订单(list < OrderDO & gtorder list){ for(order do order:order list){ handle order(order)；}}10.5.尝试使用线程池来减少线程开销。多线程中两个必要的开销:线程创建和上下文切换。通过使用线程池，可以尽可能地避免这些开销。

反例:

public void execute task(Runnable Runnable){ new Thread(Runnable)。start()；}正面例子:

private static final ExecutorService EXECUTOR _ SERVICE = executors . newfixedthreadpool(10)；public void execute task(Runnable Runnable){ executorservice . execute(Runnable)；}

后记

作为一个长期战斗在商业第一线的人& # 34；IT民工& # 34；，没有机会研究什么深奥的东西& # 34；理论& # 34；，只能关注我们面前看得见摸得着的东西& # 34；技术& # 34；，致力于做& # 34；做好一份工作，热爱一份工作，专攻一份工作& # 34；。