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 块。