JAVA的16 个实用代码优化小技巧
Posted 阿彬在上路
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVA的16 个实用代码优化小技巧相关的知识,希望对你有一定的参考价值。
一、类成员与方法的可见性最小化
举例:如果是一个private的方法,想删除就删除。
如果一个public的service方法,或者一个public的成员变量,删除一下,不得思考很多。
二、使用位移操作替代乘除法
计算机是使用二进制表示的,位移操作会极大地提高性能。
<< 左移相当于乘以 2;>> 右移相当于除以 2;
>>> 无符号右移相当于除以 2,但它会忽略符号位,空位都以 0 补齐。
a = val << 3;
b = val >> 1;
三、尽量减少对变量的重复计算
我们知道对方法的调用是有消耗的,包括创建栈帧、调用方法时保护现场,恢复现场等。
//反例
for (int i = 0; i < list.size(); i++)
System.out.println("result");
//正例
for (int i = 0, length = list.size(); i < length; i++)
System.out.println("result");
在list.size()
很大的时候,就减少了很多的消耗。
四、不要捕捉RuntimeException
RuntimeException 不应该通过 catch 语句去捕捉,而应该使用编码手段进行规避。
如下面的代码,list 可能会出现数组越界异常。
是否越界是可以通过代码提前判断的,而不是等到发生异常时去捕捉。
提前判断这种方式,代码会更优雅,效率也更高。
public String test1(List<String> list, int index)
try
return list.get(index);
catch (IndexOutOfBoundsException ex)
return null;
//正例
public String test2(List<String> list, int index)
if (index >= list.size() || index < 0)
return null;
return list.get(index);
五、使用局部变量可避免在堆上分配
由于堆资源是多线程共享的,是垃圾回收器工作的主要区域,过多的对象会造成 GC 压力,可以通过局部变量的方式,将变量在栈上分配。这种方式变量会随着方法执行的完毕而销毁,能够减轻 GC 的压力。
六、减少变量的作用范围
注意变量的作用范围,尽量减少对象的创建。
如下面的代码,变量 s 每次进入方法都会创建,可以将它移动到 if 语句内部。
public void test(String str)
final int s = 100;
if (!StringUtils.isEmpty(str))
int result = s * s;
七、尽量采用懒加载的策略,在需要的时候才创建
String str = "1";
if (name == "2")
list.add(str);
if (name == "2")
String str = "1";
list.add(str);
八、访问静态变量直接使用类名
使用对象访问静态变量,这种方式多了一步寻址操作,需要先找到变量对应的类,再找到类对应的变量。
// 反例
int i = objectA.staticMethod();
// 正例
int i = ClassA.staticMethod();
九、字符串拼接使用StringBuilder
字符串拼接,使用 StringBuilder 或者 StringBuffer,不要使用 + 号。
//反例
public class StringTest
@Test
public void testStringPlus()
String str = "111";
str += "222";
str += "333";
System.out.println(str);
//正例
public class TestMain
public static void main(String[] args)
StringBuilder sb = new StringBuilder("111");
sb.append("222");
sb.append(333);
System.out.println(sb.toString());
十、重写对象的HashCode,不要简单地返回固定值
有同学在开发重写 HashCode 和 Equals 方法时,会把 HashCode 的值返回固定的 0,而这样做是不恰当的
当这些对象存入 HashMap 时,性能就会非常低,因为 HashMap 是通过 HashCode 定位到 Hash 槽,有冲突的时候,才会使用链表或者红黑树组织节点,固定地返回 0,相当于把 Hash 寻址功能无效了。
十一、HashMap等集合初始化的时候,指定初始值大小
这样的对象有很多,比如 ArrayList,StringBuilder 等,通过指定初始值大小可减少扩容造成的性能损耗。
初始值大小计算可以参考《阿里巴巴开发手册》:
十二、循环内不要不断创建对象引用
//反例
for (int i = 1; i <= size; i++)
Object obj = new Object();
//正例
Object obj = null;
for (int i = 0; i <= size; i++)
obj = new Object();
第一种会导致内存中有size个Object对象引用存在,size很大的话,就耗费内存了
十三、遍历Map 的时候,使用 EntrySet 方法
使用 EntrySet 方法,可以直接返回 set 对象,直接拿来用即可;而使用 KeySet 方法,获得的是key 的集合,需要再进行一次 get 操作,多了一个操作步骤,所以更推荐使用 EntrySet 方式遍历 Map。
Set<Map.Entry<String, String>> entryseSet = nmap.entrySet();
for (Map.Entry<String, String> entry : entryseSet)
System.out.println(entry.getKey()+","+entry.getValue());
十四、不要在多线程下使用同一个 Random
Random 类的 seed 会在并发访问的情况下发生竞争,造成性能降低,建议在多线程环境下使用 ThreadLocalRandom 类。
public static void main(String[] args)
ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
Thread thread1 = new Thread(()->
for (int i=0;i<10;i++)
System.out.println("Thread1:"+threadLocalRandom.nextInt(10));
);
Thread thread2 = new Thread(()->
for (int i=0;i<10;i++)
System.out.println("Thread2:"+threadLocalRandom.nextInt(10));
);
thread1.start();
thread2.start();
十五、自增推荐使用LongAddr
自增运算可以通过 synchronized 和 volatile 的组合来控制线程安全,或者也可以使用原子类(比如 AtomicLong)。
后者的速度比前者要高一些,AtomicLong 使用 CAS 进行比较替换,在线程多的情况下会造成过多无效自旋,可以使用 LongAdder 替换 AtomicLong 进行进一步的性能提升。
public class Test
public int longAdderTest(Blackhole blackhole) throws InterruptedException
LongAdder longAdder = new LongAdder();
for (int i = 0; i < 1024; i++)
longAdder.add(1);
return longAdder.intValue();
十六、程序中要少用反射
反射的功能很强大,但它是通过解析字节码实现的,性能就不是很理想。
现实中有很多对反射的优化方法,比如把反射执行的过程(比如 Method)缓存起来,使用复用来加快反射速度。
Java 7.0 之后,加入了新的包java.lang.invoke
,同时加入了新的 JVM 字节码指令 invokedynamic,用来支持从 JVM 层面,直接通过字符串对目标方法进行调用。
最实用的10个重构小技巧排行榜,你都用过哪些?
LZ 最近一直在研究虚拟机源码,可惜目前还只是稍微有一点点头绪,无法与各位分享,庞大的 JAVA 虚拟机源码果然不是一朝一夕能搞定的,LZ 汗颜。本次我们抛开 JAVA 虚拟机源码这些相对底层的东西,LZ 来与各位探讨一下几个代码重构的小技巧,这些内容部分来自于书籍当中,部分来自于 LZ 维护项目当中的一些实践经验。如果猿友们曾经用过这种手法,也不妨参与到文章的留言当中,将你的小心得、小体会共享与他人,也可以拿来冲击 LZ 自己定义的排行榜,LZ 不甚欢迎。
重构的手法有很多种,相对而言,一篇文章的涵盖量自然是无法提到所有,LZ 这里也只能提出一些平时会经常使用的一些手法,像一些比较高端的手法,各位有兴趣的可以去找一些专门的书籍涉猎。
另外还有一点,由于 LZ 是做 JAVA 开发的,因此部分重构小技巧可能与 JAVA 语言,或者说与面向对象的语言息息相关,不过大多数技巧,无论是面向过程的语言,还是面向对象的语言,都是可以相互通用的。
废话不多说,我们来看看实用重构技巧的排行榜吧。
No.1:重复代码的提炼
重复代码是重构收效最大的手法之一,进行这项重构的原因不需要多说。它有很多很明显的好处,比如总代码量大大减少,维护方便,代码条理更加清晰易读。
它的重点就在于寻找代码当中完成某项子功能的重复代码,找到以后请毫不犹豫将它移动到合适的方法当中,并存放在合适的类当中。
小实例
class BadExample {
public void someMethod1(){
//code
System.out.println("重复代码");/* 重复代码块 */
//code
}
public void someMethod2(){
//code
System.out.println("重复代码");/* 重复代码块 */
//code
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
public void someMethod1(){
//code
someMethod3();
//code
}
public void someMethod2(){
//code
someMethod3();
//code
}
public void someMethod3(){
System.out.println("重复代码");/* 重复代码块 */
}
}
No.2:冗长方法的分割
有关冗长方法的分割,其实有时候与重复代码的提炼是有着不可分割的关系的,往往在我们提炼重复代码的过程中,就不知不觉的完成了对某一个超长方法的分割。倘若在你提炼了大部分的重复代码之后,某一些冗长方法依然留存,此时就要静下心来专门处理这些冗长方法了。
这其中有一点是值得注意的,由于我们在分割一个大方法时,大部分都是针对其中的一些子功能分割,因此我们需要给每一个子功能起一个恰到好处的方法名,这很重要。可以说,能否给方法起一个好名字,有时候能体现出一个程序猿的大致水准。
小实例
class BadExample {
public void someMethod(){
//function[1]
//function[2]
//function[3]
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
public void someMethod(){
function1();
function2();
function3();
}
private void function1(){
//function[1]
}
private void function2(){
//function[2]
}
private void function3(){
//function[3]
}
}
No.3:嵌套条件分支的优化(1)
?大量的嵌套条件分支是很容易让人望而却步的代码,我们应该极力避免这种代码的出现。尽管结构化原则一直在说一个函数只能有一个出口,但是在这么大量的嵌套条件分支下,让我们忘了这所谓的规则吧。
?有一个专业名词叫卫语句,可以治疗这种恐怖的嵌套条件语句。它的核心思想是,将不满足某些条件的情况放在方法前面,并及时跳出方法,以免对后面的判断造成影响。经过这项手术的代码看起来会非常的清晰,下面 LZ 就给各位举一个经典的例子,各位可以自行评判一下这两种方式,哪个让你看起来更清晰一点。
小实例
class BadExample {
public void someMethod(Object A,Object B){
if (A != null) {
if (B != null) {
//code[1]
}else {
//code[3]
}
}else {
//code[2]
}
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
public void someMethod(Object A,Object B){
if (A == null) {
//code[2]
return;
}
if (B == null) {
//code[3]
return;
}
//code[1]
}
}
No.4:嵌套条件分支的优化(2)
此处所说的嵌套条件分支与上面的有些许不同,它无法使用卫语句进行优化,而应该是将条件分支合并,以此来达到代码清晰的目的。由这两条也可以看出,嵌套条件分支在编码当中应当尽量避免,它会大大降低代码的可读性。
下面请尚且不明觉厉的猿友看下面这个典型的小例子。
小实例
class BadExample {
public void someMethod(Object A,Object B){
if (A != null) {
if (B != null) {
//code
}
}
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
public void someMethod(Object A,Object B){
if (A != null && B != null) {
//code
}
}
}
No.5:去掉一次性的临时变量
生活当中我们都经常用一次性筷子,这无疑是对树木的摧残。然而在程序当中,一次性的临时变量不仅是对性能上小小的摧残,更是对代码可读性的亵渎。因此我们有必要对一些一次性的临时变量进行手术。
小实例
class BadExample {
private int i;
public int someMethod(){
int temp = getVariable();
return temp * 100;
}
public int getVariable(){
return i;
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
private int i;
public int someMethod(){
return getVariable() * 100;
}
public int getVariable(){
return i;
}
}
No.6:消除过长参数列表
对于一些传递了大批参数的方法,对于追求代码整洁的程序猿来说,是无法接受的。我们可以尝试将这些参数封装成一个对象传递给方法,从而去除过长的参数列表。大部分情况下,当你尝试寻找这样一个对象的时候,它往往已经存在了,因此绝大多数情况下,我们并不需要做多余的工作。
小实例
class BadExample {
public void someMethod(int i,int j,int k,int l,int m,int n){
//code
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
public void someMethod(Data data){
//code
}
}
class Data{
private int i;
private int j;
private int k;
private int l;
private int m;
private int n;
//getter&&setter
}
No.7:提取类或继承体系中的常量
这项重构的目的是为了消除一些魔数或者是字符串常量等等,魔数所带来的弊端自不用说,它会让人对程序的意图产生迷惑。而对于字符串等类型的常量的消除,更多的好处在于维护时的方便。因为我们只需要修改一个常量,就可以完成对程序中所有使用该常量的代码的修改。
顺便提一句,与此类情况类似并且最常见的,就是 Action 基类中,对于 INPUT、LIST、SUCCESS 等这些常量的提取。
小实例
class BadExample {
public void someMethod1(){
send("您的操作已成功!");
}
public void someMethod2(){
send("您的操作已成功!");
}
public void someMethod3(){
send("您的操作已成功!");
}
private void send(String message){
//code
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
protected static final String SUCCESS_MESSAGE = "您的操作已成功!";
public void someMethod1(){
send(SUCCESS_MESSAGE);
}
public void someMethod2(){
send(SUCCESS_MESSAGE);
}
public void someMethod3(){
send(SUCCESS_MESSAGE);
}
private void send(String message){
//code
}
}
No.8:让类提供应该提供的方法
很多时候,我们经常会操作一个类的大部分属性,从而得到一个最终我们想要的结果。这种时候,我们应该让这个类做它该做的事情,而不应该让我们替它做。而且大部分时候,这个过程最终会成为重复代码的根源。
小实例
class BadExample {
public int someMethod(Data data){
int i = data.getI();
int j = data.getJ();
int k = data.getK();
return i * j * k;
}
public static class Data{
private int i;
private int j;
private int k;
public Data(int i, int j, int k) {
super();
this.i = i;
this.j = j;
this.k = k;
}
public int getI() {
return i;
}
public int getJ() {
return j;
}
public int getK() {
return k;
}
}
}
/* ---------------------分割线---------------------- */
class GoodExample {
public int someMethod(Data data){
return data.getResult();
}
public static class Data{
private int i;
private int j;
private int k;
public Data(int i, int j, int k) {
super();
this.i = i;
this.j = j;
this.k = k;
}
public int getI() {
return i;
}
public int getJ() {
return j;
}
public int getK() {
return k;
}
public int getResult(){
return i * j * k;
}
}
}
No.9:拆分冗长的类
这项技巧其实也是属于非常实用的一个技巧,只不过由于它的难度相对较高,因此被 LZ 排在了后面。针对这个技巧,LZ 很难像上面的技巧一样,给出一个即简单又很容易说明问题的小例子,因为它已经不仅仅是小手段了。
大部分时候,我们拆分一个类的关注点应该主要集中在类的属性上面。拆分出来的两批属性应该在逻辑上是可以分离的,并且在代码当中,这两批属性的使用也都分别集中于某一些方法当中。如果实在有一些属性同时存在于拆分后的两批方法内部,那么可以通过参数传递的方式解决这种依赖。
类的拆分是一个相对较大的工程,毕竟一个大类往往在程序中已经被很多类所使用着,因此这项重构的难度相当之大,一定要谨慎,并做好足够的测试。
No.10:提取继承体系中重复的属性与方法到父类
这项技巧大部分时候需要足够的判断力,很多时候,这其实是在向模板方法模式迈进的过程。它的实例 LZ 这里无法给出,原因是因为它的小实例会毫无意义,无非就是子类有一样的属性或者方法,然后删除子类的重复属性或方法放到父类当中。
往往这一类重构都不会是小工程,因此这一项重构与第九种类似,都需要足够的谨慎与测试。而且需要在你足够确认,这些提取到父类中的属性或方法,应该是子类的共性的时候,才可以使用这项技巧。
结束语
由于 LZ 目前的工作就是维护一个相对古老的项目,因此上面这十种手法,LZ 几乎都已经一一尝试过了,可喜的是效果都还不错。
限于最后两种与实际情况的联系太过紧密,因此 LZ 无法给出简单的实例,不过后面两种毕竟不是常用的重构手法,因此也算是可以接受了。不过不常用不代表不重要,各位猿友还是要知道这一点的。另外 LZ 还要说的是,上面的实例只是手法的一种简单展示,实际应用当中,代码的结构可能是千奇百怪,但却万变不离其宗。因此只要抓住每种手法的核心,就不难从这些乱军丛中安然穿过。
好了,本次的小分享到此结束,希望各位猿友如果觉得有所收获,可以推荐一下鼓励下 LZ,顺便也让更多的人看到。这样的话,或许我们每一个接手的项目代码,都不至于十分的糟糕了,也算是给像 LZ 这样的项目维护者一条生路吧。
- END -
最后,祝大家技术在沉淀中升华。
以上是关于JAVA的16 个实用代码优化小技巧的主要内容,如果未能解决你的问题,请参考以下文章