Java中實現代碼優化的技巧分享

Posted on by

1.用String.format拼接字符串

不知道你有沒有拼接過字符串，特別是那種有多個參數，字符串比較長的情況。

比如現在有個需求：要用get請求調用第三方接口，url後需要拼接多個參數。

以前我們的請求地址是這樣拼接的：

String url = "http://susan.sc.cn?userName="+userName+"&age="+age+"&address="+address+"&sex="+sex+"&roledId="+roleId;

字符串使用+號拼接，非常容易出錯。

後面優化瞭一下，改為使用StringBuilder拼接字符串：

StringBuilder urlBuilder = new StringBuilder("http://susan.sc.cn?");
urlBuilder.append("userName=")
.append(userName)
.append("&age=")
.append(age)
.append("&address=")
.append(address)
.append("&sex=")
.append(sex)
.append("&roledId=")
.append(roledId);

代碼優化之後，稍微直觀點。

但還是看起來比較別扭。

這時可以使用String.format方法優化：

String requestUrl = "http://susan.sc.cn?userName=%s&age=%s&address=%s&sex=%s&roledId=%s";
String url = String.format(requestUrl,userName,age,address,sex,roledId);

代碼的可讀性，一下子提升瞭很多。

我們平常可以使用String.format方法拼接url請求參數，日志打印等字符串。

但不建議在for循環中用它拼接字符串，因為它的執行效率，比使用+號拼接字符串，或者使用StringBuilder拼接字符串都要慢一些。

2.創建可緩沖的IO流

IO流想必大傢都使用得比較多，我們經常需要把數據寫入某個文件，或者從某個文件中讀取數據到內存中，甚至還有可能把文件a，從目錄b，復制到目錄c下等。

JDK給我們提供瞭非常豐富的API，可以去操作IO流。

例如：

public class IoTest1 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File("/Users/dv_susan/Documents/workspace/jump/src/main/java/com/sue/jump/service/test1/1.txt");
            File destFile = new File("/Users/dv_susan/Documents/workspace/jump/src/main/java/com/sue/jump/service/test1/2.txt");
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            int len;
            while ((len = fis.read()) != -1) {
                fos.write(len);
            }
            fos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

這個例子主要的功能，是將1.txt文件中的內容復制到2.txt文件中。這例子使用普通的IO流從功能的角度來說，也能滿足需求，但性能卻不太好。

因為這個例子中，從1.txt文件中讀一個字節的數據，就會馬上寫入2.txt文件中，需要非常頻繁的讀寫文件。

優化：

public class IoTest {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File("/Users/dv_susan/Documents/workspace/jump/src/main/java/com/sue/jump/service/test1/1.txt");
            File destFile = new File("/Users/dv_susan/Documents/workspace/jump/src/main/java/com/sue/jump/service/test1/2.txt");
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            bos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos != null) {
                    bos.close();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bis != null) {
                    bis.close();
                }
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

這個例子使用BufferedInputStream和BufferedOutputStream創建瞭可緩沖的輸入輸出流。

最關鍵的地方是定義瞭一個buffer字節數組，把從1.txt文件中讀取的數據臨時保存起來，後面再把該buffer字節數組的數據，一次性批量寫入到2.txt中。

這樣做的好處是，減少瞭讀寫文件的次數，而我們都知道讀寫文件是非常耗時的操作。也就是說使用可緩存的輸入輸出流，可以提升IO的性能，特別是遇到文件非常大時，效率會得到顯著提升。

3.減少循環次數

在我們日常開發中，循環遍歷集合是必不可少的操作。

但如果循環層級比較深，循環中套循環，可能會影響代碼的執行效率。

反例：

for(User user: userList) {
   for(Role role: roleList) {
      if(user.getRoleId().equals(role.getId())) {
         user.setRoleName(role.getName());
      }
   }
}

這個例子中有兩層循環，如果userList和roleList數據比較多的話，需要循環遍歷很多次，才能獲取我們所需要的數據，非常消耗cpu資源。

正例：

Map<Long, List<Role>> roleMap = roleList.stream().collect(Collectors.groupingBy(Role::getId));
for (User user : userList) {
    List<Role> roles = roleMap.get(user.getRoleId());
    if(CollectionUtils.isNotEmpty(roles)) {
        user.setRoleName(roles.get(0).getName());
    }
}

減少循環次數，最簡單的辦法是，把第二層循環的集合變成map，這樣可以直接通過key，獲取想要的value數據。

雖說map的key存在hash沖突的情況，但遍歷存放數據的鏈表或者紅黑樹的時間復雜度，比遍歷整個list集合要小很多。

4.用完資源記得及時關閉

在我們日常開發中，可能經常訪問資源，比如：獲取數據庫連接，讀取文件等。

我們以獲取數據庫連接為例。

反例：

//1. 加載驅動類
Class.forName("com.mysql.jdbc.Driver");
//2. 創建連接
Connection connection = DriverManager.getConnection("jdbc:mysql//localhost:3306/db?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8","root","123456");
//3.編寫sql
String sql ="select * from user";
//4.創建PreparedStatement
PreparedStatement pstmt = conn.prepareStatement(sql);
//5.獲取查詢結果
ResultSet rs = pstmt.execteQuery();
while(rs.next()){
   int id = rs.getInt("id");
   String name = rs.getString("name");
}

上面這段代碼可以正常運行，但卻犯瞭一個很大的錯誤，即：ResultSet、PreparedStatement和Connection對象的資源，使用完之後，沒有關閉。

我們都知道，數據庫連接是非常寶貴的資源。我們不可能一直創建連接，並且用完之後，也不回收，白白浪費數據庫資源。

正例：

//1. 加載驅動類
Class.forName("com.mysql.jdbc.Driver");
 
Connection connection = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
    //2. 創建連接
    connection = DriverManager.getConnection("jdbc:mysql//localhost:3306/db?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8","root","123456");
    //3.編寫sql
    String sql ="select * from user";
    //4.創建PreparedStatement
    pstmt = conn.prepareStatement(sql);
    //5.獲取查詢結果
    rs = pstmt.execteQuery();
    while(rs.next()){
       int id = rs.getInt("id");
       String name = rs.getString("name");
    }
} catch(Exception e) {
  log.error(e.getMessage(),e);
} finally {
   if(rs != null) {
      rs.close();
   }
   
   if(pstmt != null) {
      pstmt.close();
   }
   
   if(connection != null) {
      connection.close();
   }
}

這個例子中，無論是ResultSet，或者PreparedStatement，還是Connection對象，使用完之後，都會調用close方法關閉資源。

在這裡溫馨提醒一句：ResultSet，或者PreparedStatement，還是Connection對象，這三者關閉資源的順序不能反瞭，不然可能會出現異常。

5.使用池技術

我們都知道，從數據庫查數據，首先要連接數據庫，獲取Connection資源。

想讓程序多線程執行，需要使用Thread類創建線程，線程也是一種資源。

通常一次數據庫操作的過程是這樣的：

  • 創建連接
  • 進行數據庫操作
  • 關閉連接

而創建連接和關閉連接，是非常耗時的操作，創建連接需要同時會創建一些資源，關閉連接時，需要回收那些資源。

如果用戶的每一次數據庫請求，程序都都需要去創建連接和關閉連接的話，可能會浪費大量的時間。

此外，可能會導致數據庫連接過多。

我們都知道數據庫的最大連接數是有限的，以mysql為例，最大連接數是：100，不過可以通過參數調整這個數量。

如果用戶請求的連接數超過最大連接數，就會報：too many connections異常。如果有新的請求過來，會發現數據庫變得不可用。

這時可以通過命令：

show variables like max_connections

查看最大連接數。

然後通過命令：

set GLOBAL max_connections=1000

手動修改最大連接數。

這種做法隻能暫時緩解問題，不是一個好的方案，無法從根本上解決問題。

最大的問題是：數據庫連接數可以無限增長，不受控制。

這時我們可以使用數據庫連接池。

目前Java開源的數據庫連接池有：

  • DBCP：是一個依賴Jakarta commons-pool對象池機制的數據庫連接池。
  • C3P0：是一個開放源代碼的JDBC連接池，它在lib目錄中與Hibernate一起發佈，包括瞭實現jdbc3和jdbc2擴展規范說明的Connection 和Statement 池的DataSources 對象。
  • Druid：阿裡的Druid，不僅是一個數據庫連接池，還包含一個ProxyDriver、一系列內置的JDBC組件庫、一個SQL Parser。
  • Proxool：是一個Java SQL Driver驅動程序，它提供瞭對選擇的其它類型的驅動程序的連接池封裝，可以非常簡單的移植到已有代碼中。

目前用的最多的數據庫連接池是:Druid。

到此這篇關於Java中實現代碼優化的技巧分享的文章就介紹到這瞭,更多相關Java代碼優化內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：