# 七行代码的九种性能优化方法
原题如下,如下代码用于拼接字符串,试找出所有9种性能优化方法
```java
public String buildProvince(List<Org> orgs){
StringBuilder sb = new StringBuilder();
for(Org org:orgs){
if(sb.length()!=0){
sb.append(",")
}
sb.append(org.getProvinceId());
}
return sb.toString();
}
```
> 所有优化方法实现在 https://gitee.com/xiandafu/java-performance/tree/master/helloworld,优化的JMH测试结果也在例子的comment里
>
> 这个例子的9种优化方法,在本书里均有介绍
## 1 检查是否为空
提前检测参数,尽早返回可能的结果.
```java
public static String buildProvinceWithEmptyCheck(List<Org> orgs){
//检测是否为空
if(orgs.isEmpty()){
return "";
}
.......
}
```
## 2 检测集合只有一个
如果集合只有一个,则只需要做特殊处理
```java
public static String buildProvinceWithSizeCheck(List<Org> orgs){
//如果只包含一个元素
if(orgs.size()==1){
return String.valueOf(orgs.get(0).getProvinceId());
}
.......
}
```
Java的String的split方法,就是对正则表达式判断,如果长度为1,则不采用正则表达式解析字符串,从而提供系统性能
## 3 采用subString
```java
public static String buildProvinceWithSubString(List<Org> orgs){
StringBuilder sb = new StringBuilder();
for(Org org:orgs){
sb.append(org.getProvinceId()).append(",");
}
//去掉最后一个逗号
return sb.substring(0,sb.length());
}
```
这样,避免了每次循环中的使用if来判断。(注意,这里假定orgs是有值的)
## 4 使用char拼接
```java
public static String buildProvinceWithChar(List<Org> orgs){
StringBuilder sb = new StringBuilder();
for(Org org:orgs){
//使用char 代替String
sb.append(org.getProvinceId()).append(',');
}
sb.setLength(sb.length()-1);
return sb.toString();
}
```
通过StringBuilder源码,可以看到append(char)效率比append(String)要高多了
## 5 预先估计StringBuilder容量
对集合,StringBuilder等预先估计一个容量,避免容量再次增长带来的性能影响
```java
public static String buildProvinceWithInitCapacity(List<Org> orgs){
//假设省Id不超过2位,初始化一个大小
StringBuilder sb = new StringBuilder(orgs.size()*3);
.......
}
```
## 6 采用StringBuffer
StringBuffer并不比StringBuilder慢
```java
public static String buildProvinceWithStringBuffer(List<Org> orgs){
//StringBuffer
StringBuffer sb = new StringBuffer();
........
return sb.toString();
}
```
一方面虚拟机有锁逃逸优化,避免了Synchronized 带来的性能影响,另外,StringBuffer的toString方法实现比较特别,它的实现如下
```java
@Override
public synchronized String toString() {
return new String(toStringCache, true);
}
```
也就是用StringBuffer构造String的时候,复用了StringBuffer的char[], 对比StringBuilder,则采用更安全的方式,构造String的时候重新复制了一份。
## 7 provinceId提前转为字符串
int转为字符串实际上相当耗时,可以提前转化,这也是所有优化方式里最明显的的一种
```java
public static String buildProvinceWithCacheData(List<Org> orgs){
StringBuilder sb = new StringBuilder();
for(Org org:orgs){
//使用预先初始化好的chars
char[] chars = strProvince[org.getProvinceId()];
sb.append(chars).append(',');
}
sb.setLength(sb.length()-1);
return sb.toString();
}
static char[][] strProvince;
static{
strProvince = new char[31][];
for(int i=0;i<31;i++){
strProvince[i] = String.valueOf(i).toCharArray();
}
}
```
再Java源码里,int装箱成Integer,也采用预先初始化了一部分Integer数据,以提高性能
## 8 缓存StringBuilder
如果每次调用都需要构建一个StringBuilder,可以放到ThreadLocal里缓存起来,也有较好的性能
```java
public static String buildProvinceWithCache(List<Org> orgs){
StringBuilder sb = local.get();
for(Org org:orgs){
if(sb.length()!=0){
sb.append(",");
}
sb.append(org.getProvinceId());
}
String str = sb.toString();
sb.setLength(0);
return str;
}
static ThreadLocal<StringBuilder> local = ThreadLocal.withInitial((Supplier) () -> new StringBuilder());
```
在Java源码里,FloatingDecimal,用于讲Double转化String,也是采用了类似机制。 Jackson,FastJSON等高速序列化工具,也会提供可复用的输出缓存区。如Jackson使用了BufferRecycler
## 9 循环展开
其他语言都有循环展开作为性能优化,Java也有此效果,这里仅仅作为演示例子,在此场景不具备实际用途
```java
/**
* 如果预先知道容量,比如能整除4,可以减少循环判断
* @param orgs
* @return
*/
public static String buildProvinceWithLoop(List<Org> orgs){
StringBuilder sb = new StringBuilder();
int count = orgs.size()/4;
int i=0;
for(;i<count;i++){
sb.append(orgs.get(i).getProvinceId()).append(",");
sb.append(orgs.get(i+1).getProvinceId()).append(",");
sb.append(orgs.get(i+2).getProvinceId()).append(",");
sb.append(orgs.get(i+3).getProvinceId()).append(",");
}
//去掉最后一个逗号
sb.setLength(sb.length()-1);
return sb.toString();
}
```
- 内容介绍
- 第一章 Java系统优化
- 1.1 可优化的代码
- 1.2 性能监控
- 1.3 JMH
- 1.3.1 使用JMH
- 1.3.2 JMH常用设置
- 1.3.3 注意事项
- 1.3.4 单元测试
- 第二章 字符串和数字
- 2 字符串和数字操作
- 2.1 构造字符串
- 2.2 字符串拼接
- 2.3 字符串格式化
- 2.4 字符串查找
- 2.6 intern方法
- 2.7 UUID
- 2.8 StringUtils类
- 2.9 前缀树过滤
- 2.10 数字装箱
- 2.11 BigDecimal
- 第三章 并发和异步编程
- 3.1 不安全的代码
- 3.2 Java并发编程
- 3.2.1 volatile
- 3.2.2 synchronized
- 3.2.3 Lock
- 3.2.4 Condition
- 3.2.5 读写锁
- 3.2.6 semaphore
- 3.2.7 栅栏
- 3.3 Java并发工具
- 3.3.1 原子变量
- 3.3.2 Queue
- 3.3.3 Future
- 3.4 Java线程池
- 3.5 异步编程
- 3.5.1 创建异步任务
- 3.5.2 完成时回调
- 3.5.3 串行执行
- 3.5.4 并行执行
- 3.5.5 接收任务处理结果
- 第四章 代码性能优化
- 4.1 int 转 String
- 4.2 使用Native 方法
- 4.3 日期格式化
- 4.4 switch 优化
- 4.5 优先用局部变量
- 4.6 预处理
- 4.7 预分配
- 4.8 预编译
- 4.9 预先编码
- 4.10 谨慎使用Exception
- 4.11 批处理
- 4.12 展开循环
- 4.13 静态方法调用
- 4.14 高速Map存取
- 4.15 位运算
- 4.16 反射
- 4.17 压缩
- 4.18 可变数组
- 4.19 System.nanoTime()
- 4.20 ThreadLocalRandom
- 4.21 Base64
- 4.22 辨别重量级对象
- 4.23 池化技术
- 4.24 实现hashCode
- 4.25 错误优化策略
- 4.25.1 final无法帮助内联
- 4.25.2 subString 内存泄露
- 4.25.3 循环优化
- 4.25.4 循环中捕捉异常
- 4.25.5 StringBuffer性能不如StringBuilder高
- 第五章 高性能工具
- 5.1 高速缓存 caffeine
- 5.1.1 安装
- 5.1.2 caffeine 基本使用
- 5.1.3 淘汰策略
- 5.1.4 statistics 功能
- 5.1.5 caffeine高命中率
- 5.1.6 卓越性能
- 5.2 selma映射工具
- 5.3 Json工具 Jackson
- 5.3.1 Jackson三种使用方式
- 5.3.3 对象绑定
- 5.3.2 Jackson 树遍历
- 5.3.4 流式操作
- 5.3.6 自定义 JsonSerializer
- 5.3.7 集合的反序列化
- 5.3.8 性能提升和优化
- 5.4 HikariCP
- 5.4.1 HikariCP安装
- 5.4.3 HikariCP 性能测试
- 5.4.4 性能优化说明
- 5.5 文本处理Beetl
- 5.5.1 安装和配置
- 5.5.2 脚本引擎
- 5.5.3 特点
- 5.5.4 性能优化
- 5.6 MessagePack
- 5.7 ReflectASM
- 第六章 Java注释
- 6.1 JavaDoc
- 6.2 Tag
- 6.2.1 {@link}
- 6.2.2 @deprecated
- 6.2.3 {@literal}
- 6.2.4 {@code}
- 6.2.5 {@value}
- 6.2.6 @author
- 6.2.7 @param 和 @return
- 6.2.8 @throws
- 6.2.9 @see
- 6.2.10 自动拷贝
- 6.3 Package-Info
- 6.4 HTML生成
- 6.5 Markdown-doclet
- 第七章 可读性代码
- 7.1 精简注释
- 7.2 变量
- 7.2.1 变量命名
- 7.2.2 变量的位置
- 7.2.3 中间变量
- 7.3 方法
- 7.3 .1 方法签名
- 7.3.2 小方法
- 7.3.3 单一职责
- 7.3.3 小类
- 7.4 分支
- 7.4.1 if else
- 7.4.2 switch case
- 7.5 发现对象
- 7.3.1 不要用String
- 7.3.2 不要用数组,Map
- 7.6 checked异常
- 7.7 其他
- 7.7.1 避免自动格式化
- 7.7.2 关于Null
- 第八章 JIT优化
- 8.1 解释和编译
- 8.2 C1和C2
- 8.3 代码缓存
- 8.4 JITWatch
- 8.5 内联
- 8.6 虚方法调用
- 第九章 代码审查
- 9.1 ConcurrentHashMap陷阱
- 9.2 字符串搜索
- 9.3 IO输出
- 9.4 字符串拼接
- 9.5 方法的入参和出参
- 9.6 RPC调用定义的返回值
- 9.7 Integer使用
- 9.8 排序
- 9.9 判断特殊的ID
- 9.10 优化if结构
- 9.11 文件COPY
- 9.12 siwtch优化
- 9.13 Encoder
- 9.14一个JMH例子
- 9.15 注释
- 9.16 完善注释
- 9.17 方法抽取
- 9.18 遍历Map
- 9.19 日期格式化
- 9.20 日志框架设计的问题
- 9.21 持久化到数据库
- 9.22 某个RPC框架
- 9.23 循环调用
- 9.24 Lock使用
- 9.25 字符集
- 9.26 处理枚举值
- 9.27 任务执行
- 9.28 开关判断
- 9.29 JDBC操作
- 9.30 Controller代码
- 9.31 停止任务
- 9.32 log框架
- 9.33 缩短UUID
- 9.34 Dubbo ThreadPool设置
- 9.35 压缩设备信息
- 第十章 ASM运行时增强
- 10.1 Java字节码
- 10.1.1 基础知识
- 10.1.2 class文件格式
- 10.2 Java方法的执行
- 10.2.1 方法在内存的表示
- 10.2.3 方法在class文件中的表示
- 10.2.3 指令的分类
- 10.2.4 操作数栈的变化分析
- 10.3 Bytecode Outline插件
- 10.4 ASM入门
- 10.4.1 生成类名及构造函数
- 10.4.2 生成main方法
- 10.4.3 调用生成的代码
- 10.5 ASM增强代码
- 10.5.1 使用反射实现
- 10.5.2 使用ASM生成辅助类
- 10.5.3 switch语句的分类
- 10.5.4 获取bean中的property
- 10.5.5 switch语句的实现
- 10.5.6 性能对比
- 第十一章 JSR269编译时增强
- 11.1 Java编译的过程
- 11.2 注解处理器入门
- 11.3 相关概念介绍
- 11.3.1 AbstractProcessor
- 11.3.2 Element与TypeMirror
- 11.4 注解处理器进阶
- 11.4.1 JsonWriter注解
- 11.4.2 处理器与生成辅助类
- 11.4.3 使用生成的Mapper类
- 11.4.4 注解处理器的使用
- 11.5 调试注解处理器
- 11.5.1 Eclipse中调试注解处理器
- 11.5.2 Idea中调试注解处理
- 附录A OQL分析JVM内存(免费)
- 附录B 7行代码的9种性能优化方法(免费)
- 附录 C CPUCacheTest更多讨论(免费)