java代码性能优化_collection.isempty()

作者：Cpp五条 | 2024-06-18 07:58:30

踩

collection.isempty()

摘要

性能优化一直是个难题，也是需要从一点一滴优化起。在我们日常编码中注意一些细节可以极大的提升性能。

正文

map的遍历
当遍历中需要同时用到key,value是使用entrySet迭代

//反例
for (Integer key : map.keySet()) {
    System.out.println(key+","+map.get(key));
}

//正例
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey()+","+entry.getValue());
}
1
2
3
4
5
6
7
8
9

使用Collection.isEmpty()取代Collection.size()==0检测空
任何 Collection.isEmpty() 实现的时间复杂度都是 O(1) ，但是某些 Collection.size() 实现的时间复杂度可能是 O(n) 。
```
//反例
if(ls.size()==0){
	System.out.println("ls为空");
}
//正例
List<String> ls=new ArrayList<>(10);
if(ls.isEmpty()){
	System.out.println("ls为空");
}
1
2
3
4
5
6
7
8
9
```

集合初始化尽量指定大小
集合扩容很复杂，所以尽量避免集合扩容

//反例
List<String> ls2=new ArrayList<>();
//正例
List<String> ls=new ArrayList<>(10);
1
2
3
4

字符串拼接使用 StringBuilder
一般的字符串拼接在编译期 java 会进行优化，但是在循环中字符串拼接， java 编译期无法做到优化，所以需要使用 StringBuilder 进行替换。

//反例
String userName="";
for (String user : users) {
    userName=userName+","+user;
}
//正例
StringBuilder sb=new StringBuilder();
for (String user : users) {
    sb.append(",");
    sb.append(user);
}
1
2
3
4
5
6
7
8
9
10
11

频繁调用 Collection.contains 方法请使用Set
List 的 contains 方法普遍时间复杂度是 O(n) ，如果在代码中需要频繁调用 contains 方法查找数据，可以先将 list 转换成 HashSet 实现，将 O(n) 的时间复杂度降为 O(1) 。
```
//反例
for (int i = 0; i <= Integer.MAX_VALUE; i++) {
    list.contains(i);
}
//正例
Set<Integer> set = new HashSet(list);
for (int i = 0; i <= Integer.MAX_VALUE; i++) {
    set.contains(i);
}
1
2
3
4
5
6
7
8
9
```

使用String.valueOf(value)代替value+""和toString()

//反例
for (Integer i = 0; i < max; i++) {
     String str =i.toString();
 }
 for (Integer i = 0; i < max; i++) {
     String str =i+"";
 }
 //正例
 for (Integer i = 0; i < max; i++) {
     String str =String.valueOf(i);
 }
1
2
3
4
5
6
7
8
9
10
11

尽量避免在循环内部new局部变量
创建变量不仅耗费时间而且消耗内存

//反例
for (String userName : users) {
    User user=new User();
    user.setName(userName);
    userList.add(user);
}

//正例
User user=new User();
for (String userName : users) {
    user.setName(userName);
    userList.add(user);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

尽量使用final修饰符
带有final修饰符的类是不可派生的。在JAVA核心API中，有许多应用final的例子，例如java、lang、String，为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关），此举能够使性能平均提高50%。
```
private int id;
//反例
public int getId() {
    return id;
}

//正例
final public int getId() {
    return id;
}
1
2
3
4
5
6
7
8
9
10
```
尽量使用局部变量
调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快；其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。
慎用synchronized，尽量减小synchronize的方法
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。synchronize方法被调用时，直接会把当前对象锁了，在方法执行完之前其他线程无法调用当前对象的其他方法。所以，synchronize的方法尽量减小，并且应尽量使用方法同步代替代码块同步。
尽量不要使用finalize方法
将资源清理放在finalize方法中完成是非常不好的选择，由于GC的工作量很大，尤其是回收Young代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。
在线程安全前提下应尽量使用HashMap、ArrayList
HashTable、Vector等使用了同步机制，降低了性能。
量减少对变量的重复计算
在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。
```
//反例
for(int i=0;i<list.size();i++){
}
//正例
for(int i=0,len=list.size();i<len;i++){
}
1
2
3
4
5
6
```
尽量在finally块中释放资源
程序中使用到的资源应当被释放，以避免资源泄漏，这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。
尽量使用移位来代替’a/b’的操作
"/"是一个代价很高的操作，使用移位的操作将会更快和更有效。但注意的是使用移位应添加注释，因为移位操作不直观，比较难理解。
```
//反例
int num = a / 4;
int num = a / 8;
//正例
int num = a >> 2;
int num = a >> 3;
1
2
3
4
5
6
```

尽量使用移位来代替’a*b’的操作
对于’*'操作，使用移位的操作将会更快和更有效

//反例
int num = a * 4;
int num = a * 8;
//正例
int num = a << 2;
int num = a << 3;
1
2
3
4
5
6

尽量避免使用split
除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需要频繁的调用split，可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。

尽量使用System.arraycopy ()代替通过来循环复制数组
System.arraycopy() 要比通过循环来复制数组快的多。

//反例
System.arraycopy(user2,0,user3,0, user2.length);	

//正例
for (int i = 0; i < MAX_USER; i++) {
    user4[i]= user2[i];
}
1
2
3
4
5
6
7

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/734285