java優化演算法
Ⅰ java性能優化權威指南和java程序性能優化哪本好
1、調整垃圾收集(GC)
由於垃圾收集的復雜性,很難發現你的應用的准確性能。不過,如果你真的想優化你的應用,你應該相應地處理垃圾收集。通用的准則是調整GC設置並同時執行性能分析。
一旦你對結果感到滿意,你可以停止該過程並尋求其他優化方式。確保除了在平均事務處理時間之外,你還留心了異常值。這些異常值是造成Java應用緩慢的真正的罪魁禍首並且很難找到。
此外,你要明白應用運行期間性能下降的效應。在每單個cpu時鍾內的緩慢操作是可以忽略的,但在每單個資料庫事務中的緩慢操作則是非常昂貴的消耗。但是你應該根據性能短板選擇你的優化策略,並應該根據工作負載來優化應用。
2、正確地選擇適合你的GC演算法
讓我們更深入地探討GC優化。畢竟,GC優化是要處理的整個優化問題中最基本的。目前,Java中有四種供你選擇的垃圾收集演算法。每種演算法滿足不同的需求,因此你要選擇(適合你的需求的)。很多開發人員正是因為不了解GC演算法而未能優化他們的應用。
這四個演算法分別是串列回收器,並行/吞吐量回收器,CMS回收器和G1回收器。想要了解更多關於每種垃圾收集器的信息及它們是如何工作的,請查看這篇來自Takipi博客的非常棒的文章Garbage Collectors—Serial vs。 Parallel vs。 CMS vs。 G1。這篇文章同時還討論了Java8對GC演算法的影響及其他細節上的改變。讓我們再回到GC演算法上,根據Understanding Java Garbage Collection這篇文章所述,並發標記和清除GC(即」CMS」)演算法才是適合網路服務端應用的最佳演算法。並行GC演算法適合那些內部可預測的應用。
G1和CMS是並發操作的理想選擇,但仍然會引起(應用)頻繁停頓。實際的選擇取決於你如何取捨。舉例來說,盡管選擇並行演算法會帶來更長的GC停頓時間,但相較於其他GC演算法,選擇並行演算法仍是一個好主意。
3、Java堆
Java內存堆在迎合內存需求方面擔任了至關重要角色。通常更好的做法是初始時分配最小的堆,然後通過持續的測試不斷增加它的大小。大多數時候優化問題都可以通過增加堆的大小解決,但如果存在大量的GC開銷,則該解決方案不起作用。
GC開銷還會使吞吐量急劇下降,進而使得應用難以形容的慢。此外,及早調整GC可以幫助你避免堆大小分配的問題。開始的時候,你可以選擇任何1GB到8GB的堆大小。當你選擇正確的堆大小,老生代和新生代對象的概念也就不需要了。總而言之,堆大小應該取決於老生代和新生代對象的比率,之前的GC優化和對象集合(即所有對象佔用的內存大小)。
4、關鍵應用優化
關鍵代碼優化是優化你的Java應用最好的方式。如果你的應用對GC和堆優化沒有反應,那麼最好是做架構改進並關注於你的應用是如何處理信息的。使用聰明的演算法並管理好對象就能解決大量的問題,包括內存碎片,堆大小問題和垃圾收集的問題。
5、使用最優的函數
Java提供了多個函數來提升演算法效率。如果你使用StringBuilder代替簡單的String,你可以得到微乎其微的性能提升。不過,我們還有其他方式在代碼層面進行優化。讓我們看看下面這些優化方法。
使用StringBuilder代替+操作符。
避免使用iterator。
多使用棧帶來的好處。
避免使用正則表達式,使用Apache Commons Lang作為代替。
遠離遞歸。遞歸會佔用大量資源!
Ⅱ 面試Java開發時問到高並發怎麼處理的，還有sql優化有哪些辦法，有哪位大神知道啊，新手！！
Java開發高並發的處理方法：
最基礎的地方做起，優化我們寫的代碼，減少必要的資源浪費
避免頻繁的使用new對象，對於整個應用只需要存在一個實例的類，我們可以使用單例模式。對於String連接操作，使用StringBuffer或StringBuilder，對於工具類可以通過靜態方法來訪問。
避免使用錯誤的方式，盡量不用instanceof做條件判斷。使用java中效率高的類，比如ArrayList比Vector性能好。
圖片伺服器分離
對於web伺服器來說，圖片是最消耗資源的，於是我們有必要把圖片與頁面進行分離，我們把圖片放到獨立的圖片伺服器。這樣的架構可以降低提供頁面訪問請求的伺服器系統壓力，並且可以保證系統不會因為圖片的問題而崩潰。在圖片伺服器上，我們可以對不同的配置進行優化。
具體接觸過的緩存機制是hibernate的緩存機制。為了避免每次都向資料庫中取得數據，我們把用戶常常訪問到的數據放到內存中，甚至緩存十分大的時候我們可以把內存中的緩存放到硬碟中。還有高級的分布式緩存資料庫使用，都可以增加系統的抗壓力。
分批傳送
在做某項目的時候，一次傳遞的參數太多，而且資料庫規定一次最多傳遞的參數最多是三萬條，當時有五萬條記錄，那怎麼傳送呢？最終是分批傳送，電梯里一次乘不下那麼多的人，會報超重的bug，那就分批把人送上去。
還有一次在考試系統中，如果那麼多的考試人員同時提交到資料庫中，資料庫的壓力增大，有時會被down掉，當時採用的方法是使用ajax非同步傳輸，沒有等待考生點擊提交按鈕的時候，就把考生的答案自動提交，這樣也避免了突然斷電考生前面做過的題出現丟失的現象。
DB優化
在資料庫設計的時候就要考慮到後期的維護，資料庫三範式是我們設計資料庫索要遵循的原則。
索引的建立：建立索引要適當，如果一個表經常用來被查詢，對於增加和修改很少被用到，我們就可以為這個表建立索引，因為對於增加和修改和刪除操作時，我們對索引的維護要大大超過索引給我們帶來的效率。
表欄位的類型選擇要恰當。包括欄位的長度、類型等，要根據實際存儲的數據進行選擇，長度不要過長，否則會影響效率。
外鍵要慎用，因為主鍵代表這一張表，而外鍵代表一群表，對表之間進行了關聯，在刪除修改等需要我們關聯。
在資料庫操作上。 盡量使用prepareStatement，少用Statement，因為PrepareStatement是進行預編譯的。
connection設置為readOnly，Connection是對書庫連接，屬於重量級，我們使用即可。
連接池的使用，我們可以修改資料庫默認的連接數。
Ⅲ java 資料庫演算法優化
資料庫使用工廠模式，應該弄個線程池，看看書就好了，好多書上都有。
懶得寫代碼，太長了
Ⅳ java中重寫equals()、hashCode()方法有什麼好處怎麼優化演算法有沒有關於hashCode優化的電子書呢
這二個方法是父類的方法(object類)，你也可以重寫這二個方法。
equals()是二個對象比較的方法。
hashcode是取得內在地址。
Ⅳ 用java做演算法好嗎
java是建立在許多軟體基礎上的編程語言，對於演算法程序的優化手段受到很大限制，這些都不利於做演算法
可以考慮用c做演算法，可以在兼顧可移植性的同時盡量優化，然後在java中調用。
Ⅵ JAVA計算斐波那契最簡單最優化的方法
class Fibo {
public static void main(String[] args) {
System.out.println(fibo(38));
}
static long fibo(int n) {
return n < 2 ? n : fibo(n - 1) + fibo(n - 2);
}
}
Ⅶ 如何優化JAVA代碼及提高執行效率
網站優化通常包含兩方面的內容：減小代碼的體積和提高代碼的運行效率。減小代碼的體積已經寫過太多這類的文章了，下面就簡單討論下如何提高代碼的效率。一、不用new關鍵詞創建類的實例用new關鍵詞創建類的實例時，構造函數鏈中的所有構造函數都會被自動調用。但如果一個對象實現了Cloneable介面，我們可以調用它的clone()方法。clone()方法不會調用任何類構造函數。在使用設計模式(DesignPattern)的場合，如果用Factory模式創建對象，則改用clone()方法創建新的對象實例非常簡單。二、使用非阻塞I/O版本較低的JDK不支持非阻塞I/OAPI。為避免I/O阻塞，一些應用採用了創建大量線程的辦法(在較好的情況下，會使用一個緩沖池)。這種技術可以在許多必須支持並發I/O流的應用中見到，如Web伺服器、報價和拍賣應用等。然而，創建Java線程需要相當可觀的開銷。JDK1.4引入了非阻塞的I/O庫(java.nio)。如果應用要求使用版本較早的JDK，需要支持非阻塞I/O的軟體包。三、慎用異常異常對性能不利。拋出異常首先要創建一個新的對象。Throwable介面的構造函數調用名為fillInStackTrace()的本地(Native)方法，fillInStackTrace()方法檢查堆棧，收集調用跟蹤信息。只要有異常被拋出，VM就必須調整調用堆棧，因為在處理過程中創建了一個新的對象。異常只能用於錯誤處理，不應該用來控製程序流程。四、不要重復初始化變數默認情況下，調用類的構造函數時，Java會把變數初始化成確定的值：所有的對象被設置成null，整數變數(byte、short、int、long)設置成0，float和double變數設置成0.0，邏輯值設置成false。當一個類從另一個類派生時，這一點尤其應該注意，因為用new關鍵詞創建一個對象時，構造函數鏈中的所有構造函數都會被自動調用。五、盡量指定類的final修飾符帶有final修飾符的類是不可派生的。在Java核心API中，有許多應用final的例子，例如java.lang.String。為String類指定final防止了人們覆蓋length()方法。另外，如果指定一個類為final，則該類所有的方法都是final。Java編譯器會尋找機會內聯(inline)所有的final方法(這和具體的編譯器實現有關)。此舉能夠使性能平均提高50%。六、盡量使用局部變數調用方法時傳遞的參數以及在調用中創建的臨時變數都保存在棧(Stack)中，速度較快。其他變數，如靜態變數、實例變數等，都在堆(Heap)中創建，速度較慢。另外，依賴於具體的編譯器/JVM，局部變數還可能得到進一步優化，望採納，謝謝。
Ⅷ Java代碼優化有哪些方法
這個多了去了，一般需要注意的就是：
異常處理try-catch方法
進程沖突，程序死鎖。
重復代碼的優化，一般要求不要有重復的代碼應用。
無用代碼，沒有用到的當然該丟掉。
邊界測試
黑盒-白盒測試等
一般代碼是不可能沒有bug的，bug也不是全部是壞的。
Ⅸ 50分求java一個關於優化演算法的問題
// TimeAndCost.java 月/萬
public class TimeAndCost {
private int time;
private int cost;
public TimeAndCost(int time, int cost) {
this.time = time;
this.cost = cost;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public int getCost() {
return cost;
}
public void setCost(int cost) {
this.cost = cost;
}
@Override
public String toString() {
return time + "/" + cost;
}
}
// Solution.java 解決方案
import java.util.ArrayList;
import java.util.List;
public class Solution {
private List<TimeAndCost> list = new ArrayList<TimeAndCost>();
public void add(TimeAndCost tac) {
list.add(tac);
}
public int totalTime() {
int result = 0;
for (TimeAndCost tac : list) {
result += tac.getTime();
}
return result;
}
public int totalCost() {
int result = 0;
for (TimeAndCost tac : list) {
result += tac.getCost();
}
return result;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Solution: ");
for (TimeAndCost tac : list) {
builder.append(tac);
builder.append(", ");
}
builder.delete(builder.length() - 2, builder.length());
builder.append("\n");
builder.append("TotalTime: ");
builder.append(totalTime());
builder.append("\n");
builder.append("TotalCost: ");
builder.append(totalCost());
builder.append("\n");
return builder.toString();
}
}
// Client.java 客戶代碼
import java.util.ArrayList;
import java.util.List;
public class Client {
public static void main(String[] args) throws Exception {
TimeAndCost[] section1 = { new TimeAndCost(5, 5), new TimeAndCost(4, 7), new TimeAndCost(2, 10) };
TimeAndCost[] section2 = { new TimeAndCost(3, 6), new TimeAndCost(2, 8), new TimeAndCost(1, 12) };
TimeAndCost[] section3 = { new TimeAndCost(6, 1), new TimeAndCost(4, 1), new TimeAndCost(2, 3) };
TimeAndCost[] section4 = { new TimeAndCost(5, 8), new TimeAndCost(4, 10), new TimeAndCost(3, 15) };
List<Solution> solutions = new ArrayList<Solution>();
for (int a = 0; a < section1.length; a++) {
for (int b = 0; b < section2.length; b++) {
for (int c = 0; c < section3.length; c++) {
for (int d = 0; d < section4.length; d++) {
Solution solution = new Solution();
solution.add(section1[a]);
solution.add(section2[b]);
solution.add(section3[c]);
solution.add(section4[d]);
solutions.add(solution);
}
}
}
}
Solution bestSolution = null;
for(Solution solution : solutions){
if(solution.totalTime() < 12){
if(bestSolution == null){
bestSolution = solution;
continue;
}
if(solution.totalCost() < bestSolution.totalCost()){
bestSolution = solution;
}
}
}
System.out.println(bestSolution);
}
}
==================================================================
這肯定不是最佳演算法
這是窮舉法~
不過是用面向對象的思想寫的
最後的輸出結果為：
Solution: 2/10, 3/6, 2/3, 4/10
TotalTime: 11
TotalCost: 29
==================================================================
這道題目我覺得如果用純面向過程的思考方式去做的話會很亂
最後寫出的代碼會和jing5083394類似
不過寫成那樣的話不是更加不好理解嗎
我覺得還是用面向對象的思考方式去做比較好……
如果你看不懂我可以適當加點注釋
如果你實在想按照jing5083394那樣寫法的話我下午可以試著寫個
- -
==================================================================
public class Client {
public static void main(String[] args) throws Exception {
// 初始化數據
int[][] section1 = { { 5, 5 }, { 4, 7 }, { 2, 10 } };
int[][] section2 = { { 3, 6 }, { 2, 8 }, { 1, 12 } };
int[][] section3 = { { 6, 1 }, { 4, 1 }, { 2, 3 } };
int[][] section4 = { { 5, 8 }, { 4, 10 }, { 3, 15 } };
// 找出最佳方案
int[][] bestSolution = null;
for (int a = 0; a < section1.length; a++) {
for (int b = 0; b < section2.length; b++) {
for (int c = 0; c < section3.length; c++) {
for (int d = 0; d < section4.length; d++) {
int[][] tempSolution = new int[4][2];
tempSolution[0] = section1[a];
tempSolution[1] = section2[b];
tempSolution[2] = section3[c];
tempSolution[3] = section4[d];
if (getTime(tempSolution) < 12) {
bestSolution = getBetterOne(bestSolution, tempSolution);
}
}
}
}
}
// 列印
printSolution(bestSolution);
}
// 計算指定方案花費的時間
public static int getTime(int[][] solution) {
if (solution == null)
return Integer.MAX_VALUE;
int result = 0;
for (int i = 0; i < 4; i++) {
result += solution[i][0];
}
return result;
}
// 計算指定方案花費的資金
public static int getCost(int[][] solution) {
if (solution == null)
return Integer.MAX_VALUE;
int result = 0;
for (int i = 0; i < 4; i++) {
result += solution[i][1];
}
return result;
}
// 比較兩個方案
public static int[][] getBetterOne(int[][] a, int[][] b) {
if (getCost(a) < getCost(b))
return a;
else
return b;
}
// 列印指定方案
public static void printSolution(int[][] solution){
System.out.print("最佳方案：");
for(int i = 0; i < 4; i++){
System.out.print(solution[i][0] + "/" + solution[i][1] + " ");
}
System.out.println();
System.out.println("花費時間：" + getTime(solution));
System.out.println("花費資金：" + getCost(solution));
}
}
最後輸出結果為：
最佳方案：2/10 2/8 2/3 5/8
花費時間：11
花費資金：29
Ⅹ java線程優化問題
a1,a2,b1,b2對應的庫不一樣，天然不影響。
你這邊最應該考慮的是對單個產品進行線程的時候，需要線程安全。
推薦一個關鍵字：
synchronized 關鍵字，代表這個方法加鎖,相當於不管哪一個線程（例如線程A），運行到這個方法時,都要檢查有沒有其它線程B（或者C、 D等）正在用這個方法(或者該類的其他同步方法)，有的話要等正在使用synchronized方法的線程B（或者C 、D）運行完這個方法後再運行此線程A,沒有的話,鎖定調用者,然後直接運行。它包括兩種用法：synchronized 方法和 synchronized 塊。