java抢标代码 java抢购

java编程的冒泡等排序示例

Java排序算法

创新互联建站成立十多年来,这条路我们正越走越好,积累了技术与客户资源,形成了良好的口碑。为客户提供成都网站设计、做网站、网站策划、网页设计、申请域名、网络营销、VI设计、网站改版、漏洞修补等服务。网站是否美观、功能强大、用户体验好、性价比高、打开快等等,这些对于网站建设都非常重要,创新互联建站通过对建站技术性的掌握、对创意设计的研究为客户提供一站式互联网解决方案,携手广大客户,共同发展进步。

1)分类:

1)插入排序(直接插入排序、希尔排序)

2)交换排序(冒泡排序、快速排序)

3)选择排序(直接选择排序、堆排序)

4)归并排序

5)分配排序(箱排序、基数排序)

所需辅助空间最多:归并排序

所需辅助空间最少:堆排序

平均速度最快:快速排序

不稳定:快速排序,希尔排序,堆排序。

1)选择排序算法的时候

1.数据的规模 ; 2.数据的类型 ; 3.数据已有的顺序

一般来说,当数据规模较小时,应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。 考虑数据的类型,比如如果全部是正整数,那么考虑使用桶排序为最优。 考虑数据已有顺序,快排是一种不稳定的排序(当然可以改进),对于大部分排好的数据,快排会浪费大量不必要的步骤。数据量极小,而起已经基本排好序,冒泡是最佳选择。我们说快排好,是指大量随机数据下,快排效果最理想。而不是所有情况。

3)总结:

——按平均的时间性能来分:

1)时间复杂度为O(nlogn)的方法有:快速排序、堆排序和归并排序,其中以快速排序为最好;

2)时间复杂度为O(n2)的有:直接插入排序、起泡排序和简单选择排序,其中以直接插入为最好,特 别是对那些对关键字近似有序的记录序列尤为如此;

3)时间复杂度为O(n)的排序方法只有,基数排序。

当待排记录序列按关键字顺序有序时,直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言,这是最不好的情况,此时的时间性能蜕化为O(n2),因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。

——按平均的空间性能来分(指的是排序过程中所需的辅助空间大小):

1) 所有的简单排序方法(包括:直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1);

2) 快速排序为O(logn ),为栈所需的辅助空间;

3) 归并排序所需辅助空间最多,其空间复杂度为O(n );

4)链式基数排序需附设队列首尾指针,则空间复杂度为O(rd )。

——排序方法的稳定性能:

1) 稳定的排序方法指的是,对于两个关键字相等的记录,它们在序列中的相对位置,在排序之前和 经过排序之后,没有改变。

2) 当对多关键字的记录序列进行LSD方法排序时,必须采用稳定的排序方法。

3) 对于不稳定的排序方法,只要能举出一个实例说明即可。

4) 快速排序,希尔排序和堆排序是不稳定的排序方法。

4)插入排序:

包括直接插入排序,希尔插入排序。

直接插入排序: 将一个记录插入到已经排序好的有序表中。

1, sorted数组的第0个位置没有放数据。

2,从sorted第二个数据开始处理:

如果该数据比它前面的数据要小,说明该数据要往前面移动。

首先将该数据备份放到 sorted的第0位置当哨兵。

然后将该数据前面那个数据后移。

然后往前搜索,找插入位置。

找到插入位置之后讲 第0位置的那个数据插入对应位置。

O(n*n), 当待排记录序列为正序时,时间复杂度提高至O(n)。

希尔排序(缩小增量排序 diminishing increment sort):先将整个待排记录序列分割成若干个子序列分别进行直接插入排序,待整个序列中的记录基本有序时,再对全体记录进行一次直接插入排序。

面试穿什么,这里找答案!

插入排序Java代码:

public class InsertionSort {

// 插入排序:直接插入排序 ,希尔排序

public void straightInsertionSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=2;jsortedLen;j++){

if(sorted[j]sorted[j-1]){

sorted[0]= sorted[j];//先保存一下后面的那个

sorted[j]=sorted[j-1];// 前面的那个后移。

int insertPos=0;

for(int k=j-2;k=0;k--){

if(sorted[k]sorted[0]){

sorted[k+1]=sorted[k];

}else{

insertPos=k+1;

break;

}

}

sorted[insertPos]=sorted[0];

}

}

}

public void shellInertionSort(double [] sorted, int inc){

int sortedLen= sorted.length;

for(int j=inc+1;jsortedLen;j++ ){

if(sorted[j]sorted[j-inc]){

sorted[0]= sorted[j];//先保存一下后面的那个

int insertPos=j;

for(int k=j-inc;k=0;k-=inc){

if(sorted[k]sorted[0]){

sorted[k+inc]=sorted[k];

//数据结构课本上这个地方没有给出判读,出错:

if(k-inc=0){

insertPos = k;

}

}else{

insertPos=k+inc;

break;

}

}

sorted[insertPos]=sorted[0];

}

}

}

public void shellInsertionSort(double [] sorted){

int[] incs={7,5,3,1};

int num= incs.length;

int inc=0;

for(int j=0;jnum;j++){

inc= incs[j];

shellInertionSort(sorted,inc);

}

}

public static void main(String[] args) {

Random random= new Random(6);

int arraysize= 21;

double [] sorted=new double[arraysize];

System.out.print("Before Sort:");

for(int j=1;jarraysize;j++){

sorted[j]= (int)(random.nextDouble()* 100);

System.out.print((int)sorted[j]+" ");

}

System.out.println();

InsertionSort sorter=new InsertionSort();

// sorter.straightInsertionSort(sorted);

sorter.shellInsertionSort(sorted);

System.out.print("After Sort:");

for(int j=1;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

面试穿什么,这里找答案!

5)交换排序:

包括冒泡排序,快速排序。

冒泡排序法:该算法是专门针对已部分排序的数据进行排序的一种排序算法。如果在你的数据清单中只有一两个数据是乱序的话,用这种算法就是最快的排序算法。如果你的数据清单中的数据是随机排列的,那么这种方法就成了最慢的算法了。因此在使用这种算法之前一定要慎重。这种算法的核心思想是扫描数据清单,寻找出现乱序的两个相邻的项目。当找到这两个项目后,交换项目的位置然后继续扫描。重复上面的操作直到所有的项目都按顺序排好。

快速排序:通过一趟排序,将待排序记录分割成独立的两个部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。具体做法是:使用两个指针low,high, 初值分别设置为序列的头,和序列的尾,设置pivotkey为第一个记录,首先从high开始向前搜索第一个小于pivotkey的记录和pivotkey所在位置进行交换,然后从low开始向后搜索第一个大于pivotkey的记录和此时pivotkey所在位置进行交换,重复知道low=high了为止。

交换排序Java代码:

public class ExchangeSort {

public void BubbleExchangeSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=sortedLen;j0;j--){

int end= j;

for(int k=1;kend-1;k++){

double tempB= sorted[k];

sorted[k]= sorted[k]sorted[k+1]?

sorted[k]:sorted[k+1];

if(Math.abs(sorted[k]-tempB)10e-6){

sorted[k+1]=tempB;

}

}

}

}

public void QuickExchangeSortBackTrack(double [] sorted,

int low,int high){

if(lowhigh){

int pivot= findPivot(sorted,low,high);

QuickExchangeSortBackTrack(sorted,low,pivot-1);

QuickExchangeSortBackTrack(sorted,pivot+1,high);

}

}

public int findPivot(double [] sorted, int low, int high){

sorted[0]= sorted[low];

while(lowhigh){

while(lowhigh sorted[high]= sorted[0])--high;

sorted[low]= sorted[high];

while(lowhigh sorted[low]=sorted[0])++low;

sorted[high]= sorted[low];

}

sorted[low]=sorted[0];

return low;

}

public static void main(String[] args) {

Random random= new Random(6);

int arraysize= 21;

double [] sorted=new double[arraysize];

System.out.print("Before Sort:");

for(int j=1;jarraysize;j++){

sorted[j]= (int)(random.nextDouble()* 100);

System.out.print((int)sorted[j]+" ");

}

System.out.println();

ExchangeSort sorter=new ExchangeSort();

// sorter.BubbleExchangeSort(sorted);

sorter.QuickExchangeSortBackTrack(sorted, 1, arraysize-1);

System.out.print("After Sort:");

for(int j=1;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

6)选择排序:

分为直接选择排序, 堆排序

直接选择排序:第i次选取 i到array.Length-1中间最小的值放在i位置。

堆排序:首先,数组里面用层次遍历的顺序放一棵完全二叉树。从最后一个非终端结点往前面调整,直到到达根结点,这个时候除根节点以外的所有非终端节点都已经满足堆得条件了,于是需要调整根节点使得整个树满足堆得条件,于是从根节点开始,沿着它的儿子们往下面走(最大堆沿着最大的儿子走,最小堆沿着最小的儿子走)。 主程序里面,首先从最后一个非终端节点开始调整到根也调整完,形成一个heap, 然后将heap的根放到后面去(即:每次的树大小会变化,但是 root都是在1的位置,以方便计算儿子们的index,所以如果需要升序排列,则要逐步大顶堆。因为根节点被一个个放在后面去了。 降序排列则要建立小顶堆)

代码中的问题: 有时候第2个和第3个顺序不对(原因还没搞明白到底代码哪里有错)

选择排序Java代码:

public class SelectionSort {

public void straitSelectionSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=1;jsortedLen;j++){

int jMin= getMinIndex(sorted,j);

exchange(sorted,j,jMin);

}

}

public void exchange(double [] sorted,int i,int j){

int sortedLen= sorted.length;

if(isortedLen jsortedLen ij i=0 j=0){

double temp= sorted[i];

sorted[i]=sorted[j];

sorted[j]=temp;

}

}

public int getMinIndex(double [] sorted, int i){

int sortedLen= sorted.length;

int minJ=1;

double min= Double.MAX_VALUE;

for(int j=i;jsortedLen;j++){

if(sorted[j]min){

min= sorted[j];

minJ= j;

}

}

return minJ;

}

public void heapAdjust(double [] sorted,int start,int end){

if(startend){

double temp= sorted;

// 这个地方jend与课本不同,j=end会报错:

for(int j=2*start;jend;j *=2){

if(j+1end sorted[j]-sorted[j+1]10e-6){

++j;

}

if(temp=sorted[j]){

break;

}

sorted=sorted[j];

start=j;

}

sorted=temp;

}

}

public void heapSelectionSort(double [] sorted){

int sortedLen = sorted.length;

for(int i=sortedLen/2;i0;i--){

heapAdjust(sorted,i,sortedLen);

}

for(int i=sortedLen;i1;--i){

exchange(sorted,1,i);

heapAdjust(sorted,1,i-1);

}

}

public static void main(String [] args){

Random random= new Random(6);

int arraysize=9;

double [] sorted=new double[arraysize];

System.out.print("Before Sort:");

for(int j=1;jarraysize;j++){

sorted[j]= (int)(random.nextDouble()* 100);

System.out.print((int)sorted[j]+" ");

}

System.out.println();

SelectionSort sorter=new SelectionSort();

// sorter.straitSelectionSort(sorted);

sorter.heapSelectionSort(sorted);

System.out.print("After Sort:");

for(int j=1;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

面试穿什么,这里找答案!

7)归并排序:

将两个或两个以上的有序表组合成一个新的有序表。归并排序要使用一个辅助数组,大小跟原数组相同,递归做法。每次将目标序列分解成两个序列,分别排序两个子序列之后,再将两个排序好的子序列merge到一起。

归并排序Java代码:

public class MergeSort {

private double[] bridge;//辅助数组

public void sort(double[] obj){

if (obj == null){

throw new NullPointerException("

The param can not be null!");

}

bridge = new double[obj.length]; // 初始化中间数组

mergeSort(obj, 0, obj.length - 1); // 归并排序

bridge = null;

}

private void mergeSort(double[] obj, int left, int right){

if (left right){

int center = (left + right) / 2;

mergeSort(obj, left, center);

mergeSort(obj, center + 1, right);

merge(obj, left, center, right);

}

}

private void merge(double[] obj, int left,

int center, int right){

int mid = center + 1;

int third = left;

int tmp = left;

while (left = center mid = right){

// 从两个数组中取出小的放入中间数组

if (obj[left]-obj[mid]=10e-6){

bridge[third++] = obj[left++];

} else{

bridge[third++] = obj[mid++];

}

}

// 剩余部分依次置入中间数组

while (mid = right){

bridge[third++] = obj[mid++];

}

while (left = center){

bridge[third++] = obj[left++];

}

// 将中间数组的内容拷贝回原数组

copy(obj, tmp, right);

}

private void copy(double[] obj, int left, int right)

{

while (left = right){

obj[left] = bridge[left];

left++;

}

}

public static void main(String[] args) {

Random random = new Random(6);

int arraysize = 10;

double[] sorted = new double[arraysize];

System.out.print("Before Sort:");

for (int j = 0; j arraysize; j++) {

sorted[j] = (int) (random.nextDouble() * 100);

System.out.print((int) sorted[j] + " ");

}

System.out.println();

MergeSort sorter = new MergeSort();

sorter.sort(sorted);

System.out.print("After Sort:");

for (int j = 0; j sorted.length; j++) {

System.out.print((int) sorted[j] + " ");

}

System.out.println();

}

}

面试穿什么,这里找答案!

8)基数排序:

使用10个辅助队列,假设最大数的数字位数为 x, 则一共做 x次,从个位数开始往前,以第i位数字的大小为依据,将数据放进辅助队列,搞定之后回收。下次再以高一位开始的数字位为依据。

以Vector作辅助队列,基数排序的Java代码:

public class RadixSort {

private int keyNum=-1;

private VectorVectorDouble util;

public void distribute(double [] sorted, int nth){

if(nth=keyNum nth0){

util=new VectorVectorDouble();

for(int j=0;j10;j++){

Vector Double temp= new Vector Double();

util.add(temp);

}

for(int j=0;jsorted.length;j++){

int index= getNthDigit(sorted[j],nth);

util.get(index).add(sorted[j]);

}

}

}

public int getNthDigit(double num,int nth){

String nn= Integer.toString((int)num);

int len= nn.length();

if(len=nth){

return Character.getNumericValue(nn.charAt(len-nth));

}else{

return 0;

}

}

public void collect(double [] sorted){

int k=0;

for(int j=0;j10;j++){

int len= util.get(j).size();

if(len0){

for(int i=0;ilen;i++){

sorted[k++]= util.get(j).get(i);

}

}

}

util=null;

}

public int getKeyNum(double [] sorted){

double max= Double.MIN_VALUE;

for(int j=0;jsorted.length;j++){

if(sorted[j]max){

max= sorted[j];

}

}

return Integer.toString((int)max).length();

}

public void radixSort(double [] sorted){

if(keyNum==-1){

keyNum= getKeyNum(sorted);

}

for(int i=1;i=keyNum;i++){

distribute(sorted,i);

collect(sorted);

}

}

public static void main(String[] args) {

Random random = new Random(6);

int arraysize = 21;

double[] sorted = new double[arraysize];

System.out.print("Before Sort:");

for (int j = 0; j arraysize; j++) {

sorted[j] = (int) (random.nextDouble() * 100);

System.out.print((int) sorted[j] + " ");

}

System.out.println();

RadixSort sorter = new RadixSort();

sorter.radixSort(sorted);

System.out.print("After Sort:");

for (int j = 0; j sorted.length; j++) {

System.out.print((int) sorted[j] + " ");

}

System.out.println();

}

}

//copy而来

做java软件工程师,怎样才能写出好的代码?

Java代码之于java程序员而言就是左膀右臂,java代码写的好的java程序员明显更是企业的欢迎,一个优秀的java程序员的考核标准之一也是看他的编程水平。

其实有的java程序员java代码会受到大家的追捧,是因为他在写代码时注意的细节往往多于那些不怎么关注java代码编程细节的程序员,俗话说:“细节决定成败”,那么如何写出好的java代码呢?IT培训介绍一起来讨论下:

1.重视注释

有的java程序员在写代码时,从来没有想过要在java代码后加上相关的注释,甚至是上万行的代码也没有想过加上注释,这就存在很大的问题,不说你的代码会跟其他人分享讨论,就你自己回顾你是怎么写好这篇代码的,你也是半天无法理出头绪,这就为维护和修改等等工作添加了很大的麻烦。所以,要想写出好的java代码,一定从简短的java代码编写开始注重在java代码后面加上相应的注释,养成良好的习惯。

2.重视排版整洁

看很多java程序员的排版总觉得在欣赏一幅艺术品,但是看到一些java程序员的排版却总觉得无力吐槽。同样是编写代码,但是给人的视觉体验是相当的不同,当然好的java代码给人的享受也是美的,所以要想写出好的代码,一定要重视排版整洁。

3.注重命名规则

现在在一个团队开发中,都会提前定制一个统一的命名规则,这样利于提高工作效益。但是很多java程序员是缺乏这个意识的,每次敲代码,更喜欢按照自己惯常的方式老命名模块、函数,这样是方便了自己,但是忽视团队协作,所以在日常工作中,特别是团队工作中一定要重视命名规则。

4.养成备份习惯

备份的重要性不用小编强调,相必你也知道。但是有的java程序员就是没有养成这样的好习惯,每次敲完代码就不记得随手保存,每次等到除了事故,比如电脑出了故障,辛辛苦苦敲打的java代码没保存找不回来的情况下就开始懊恼,与其这样还不如在一开始就养成良好的备份习惯,这样也方便自己日后查找利用。

如何优化JAVA代码及提高执行效率

可供程序利用的资源(内存、CPU时间、网络带宽等)是有限的,优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容:减小代码的体积,提高代码的运行效率。本文讨论的主要是如何提高代码的效率。

在Java程序中,性能问题的大部分原因并不在于Java语言,而是在于程序本身。养成好的代码编写习惯非常重要,比如正确地、巧妙地运用java.lang.String类和java.util.Vector类,它能够显著地提高程序的性能。下面我们就来具体地分析一下这方面的问题。

1、 尽量指定类的final修饰符带有final修饰符的类是不可派生的。在Java核心API中,有许多应用final的例子,例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外,如果指定一个类为final,则该类所有的方法都是final。Java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%

2、 尽量重用对象。特别是String 对象的使用中,出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象,以后可能还需花时间对这些对象进行垃圾回收和处理。因此,生成过多的对象将会给程序的性能带来很大的影响。

3、 尽量使用局部变量,调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中,速度较快。其他变量,如静态变量、实例变量等,都在堆(Heap)中创建,速度较慢。另外,依赖于具体的编译器/JVM,局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

4、 不要重复初始化变量 默认情况下,调用类的构造函数时,

Java会把变量初始化成确定的值:所有的对象被设置成null,整数变量(byte、short、int、long)设置成0,float和double变量设置成0.0,逻辑值设置成false。当一个类从另一个类派生时,这一点尤其应该注意,因为用new关键词创建一个对象时,构造函数链中的所有构造函数都会被自动调用。

5、 在JAVA + ORACLE 的应用系统开发中,java中内嵌的SQL语句尽量使用大写的形式,以减轻ORACLE解析器的解析负担。

6、 Java 编程过程中,进行数据库连接、I/O流操作时务必小心,在使用完毕后,即使关闭以释放资源。因为对这些大对象的操作会造成系统大的开销,稍有不慎,会导致严重的后果。

7、 由于JVM的有其自身的GC机制,不需要程序开发者的过多考虑,从一定程度上减轻了开发者负担,但同时也遗漏了隐患,过分的创建对象会消耗系统的大量内存,严重时会导致内存泄露,因此,保证过期对象的及时回收具有重要意义。JVM回收垃圾的条件是:对象不在被引用;然而,JVM的GC并非十分的机智,即使对象满足了垃圾回收的条件也不一定会被立即回收。所以,建议我们在对象使用完毕,应手动置成null。

8、 在使用同步机制时,应尽量使用方法同步代替代码块同步。

9、 尽量减少对变量的重复计算

例如:for(int i = 0;i list.size; i ++) {

}

应替换为:

for(int i = 0,int len = list.size();i len; i ++) {

}

10、尽量采用lazy loading 的策略,即在需要的时候才开始创建。

例如: String str = “aaa”;

if(i == 1) {

list.add(str);

}

应替换为:

if(i == 1) {

String str = “aaa”;

list.add(str);

}

11、慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地(Native)方法,fillInStackTrace()方法检查堆栈,收集调用跟踪信息。只要有异常被抛出,VM就必须调整调用堆栈,因为在处理过程中创建了一个新的对象。异常只能用于错误处理,不应该用来控制程序流程。

12、不要在循环中使用:

Try {

} catch() {

}

应把其放置在最外层。

13、StringBuffer 的使用:

StringBuffer表示了可变的、可写的字符串。

有三个构造方法 :

StringBuffer (); //默认分配16个字符的空间

StringBuffer (int size); //分配size个字符的空间

StringBuffer (String str); //分配16个字符+str.length()个字符空间

你可以通过StringBuffer的构造函数来设定它的初始化容量,这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int

length),length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int

minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为,然后再找出一条更好的提升性能的途径。

StringBuffer在内部维护一个字符数组,当你使用缺省的构造函数来创建StringBuffer对象的时候,因为没有设置初始化字符长度,StringBuffer的容量被初始化为16个字符,也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候,它会将自身容量增加到当前的2倍再加2,也就是(2*旧值+2)。如果你使用缺省值,初始化之后接着往里面追加字符,在你追加到第16个字符的时候它会将容量增加到34(2*16+2),当追加到34个字符的时候就会将容量增加到70(2*34+2)。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的,这样会带来立竿见影的性能增益。

StringBuffer初始化过程的调整的作用由此可见一斑。所以,使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。

14、合理的使用Java类 java.util.Vector。

简单地说,一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似,它的元素可以通过整数形式的索引访问。但是,Vector类型的对象在创建之后,对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子:

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0;

I100000; I++) { v.add(0,obj); }

除非有绝对充足的理由要求每次都把新元素插入到Vector的前面,否则上面的代码对性能不利。在默认构造函数中,Vector的初始存储能力是10个元素,如果新元素加入时存储能力不足,则以后存储能力每次加倍。Vector类就象StringBuffer类一样,每次扩展存储能力时,所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级:

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0; I100000; I++) { v.add(obj); }

同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”,删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说,从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。

假设要从前面的Vector删除所有元素,我们可以使用这种代码:

for(int I=0; I100000; I++)

{

 v.remove(0);

}

但是,与下面的代码相比,前面的代码要慢几个数量级:

for(int I=0; I100000; I++)

{

 v.remove(v.size()-1);

}

从Vector类型的对象v删除所有元素的最好方法是:

v.removeAllElements();

假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码,它要从这个Vector中删除“Hello”字符串:

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(s);

这些代码看起来没什么错误,但它同样对性能不利。在这段代码中,indexOf()方法对v进行顺序搜索寻找字符串“Hello”,remove(s)方法也要进行同样的顺序搜索。改进之后的版本是:

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(i);

这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置,从而避免了第二次搜索。一个更好的版本是:

String s = "Hello"; v.remove(s);

最后,我们再来看一个有关Vector类的代码片段:

for(int I=0; I++;I v.length)

如果v包含100,000个元素,这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法,但它仍旧需要一次方法调用的开销,至少JVM需要为它配置以及清除堆栈环境。在这里,for循环内部的代码不会以任何方式修改Vector类型对象v的大小,因此上面的代码最好改写成下面这种形式:

int size = v.size(); for(int I=0; I++;Isize)

虽然这是一个简单的改动,但它仍旧赢得了性能。毕竟,每一个CPU周期都是宝贵的。

15、当复制大量数据时,使用System.arraycopy()命令。

16、代码重构:增强代码的可读性。

例如:

public class ShopCart {

private List carts ;

public void add (Object item) {

if(carts == null) {

carts = new ArrayList();

}

crts.add(item);

}

public void remove(Object item) {

if(carts. contains(item)) {

carts.remove(item);

}

}

public List getCarts() {

//返回只读列表

return Collections.unmodifiableList(carts);

}

//不推荐这种方式

//this.getCarts().add(item);

}

17、不用new关键词创建类的实例

用new关键词创建类的实例时,构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口,我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。

在使用设计模式(Design Pattern)的场合,如果用Factory模式创建对象,则改用clone()方法创建新的对象实例非常简单。例如,下面是Factory模式的一个典型实现:

public static Credit getNewCredit() {

return new Credit();

}

改进后的代码使用clone()方法,如下所示:

private static Credit BaseCredit = new Credit();

public static Credit getNewCredit() {

return (Credit) BaseCredit.clone();

}

上面的思路对于数组处理同样很有用。

18、乘法和除法

考虑下面的代码:

for (val = 0; val 100000; val +=5) {

alterX = val * 8; myResult = val * 2;

}

用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码:

for (val = 0; val 100000; val += 5) {

alterX = val 3; myResult = val 1;

}

修改后的代码不再做乘以8的操作,而是改用等价的左移3位操作,每左移1位相当于乘以2。相应地,右移1位操作相当于除以2。值得一提的是,虽然移位操作速度快,但可能使代码比较难于理解,所以最好加上一些注释。

19、在JSP页面中关闭无用的会话。

一个常见的误解是以为session在有客户端访问时就被创建,然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建,注意如果JSP没有显示的使用 %@pagesession="false"% 关闭session,则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession

session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源,因此,如果不打算使用session,应该在所有的JSP中关闭它。

对于那些无需跟踪会话状态的页面,关闭自动创建的会话可以节省一些资源。使用如下page指令:%@ page session="false"%

20、JDBC与I/O

如果应用程序需要访问一个规模很大的数据集,则应当考虑使用块提取方式。默认情况下,JDBC每次提取32行数据。举例来说,假设我们要遍历一个5000行的记录集,JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512,则调用数据库的次数将减少到10次。

[p][/p]21、Servlet与内存使用

许多开发者随意地把大量信息保存到用户会话之中。一些时候,保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看,典型的症状是用户感到系统周期性地变慢,却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间,它的表现是内存占用不正常地大起大落。

解决这类内存问题主要有二种办法。第一种办法是,在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样,只要实现valueUnbound()方法,就可以显式地释放Bean使用的资源。另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外,也可以用编程的方式调用会话的setMaxInactiveInterval()方法,该方法用来设定在作废会话之前,Servlet容器允许的客户请求的最大间隔时间,以秒计。

22、使用缓冲标记

一些应用服务器加入了面向JSP的缓冲标记功能。例如,BEA的WebLogic Server从6.0版本开始支持这个功能,Open

Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断,也能够缓冲整个页面。当JSP页面执行时,如果目标片断已经在缓冲之中,则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求,并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说,这个功能极其有用。对于这类应用,页面级缓冲能够保存页面执行的结果,供后继请求使用。

23、选择合适的引用机制

在典型的JSP应用系统中,页头、页脚部分往往被抽取出来,然后根据需要引入页头、页脚。当前,在JSP页面中引入外部资源的方法主要有两种:include指令,以及include动作。

include指令:例如%@ include file="copyright.html"

%。该指令在编译时引入指定的资源。在编译之前,带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定,比运行时才确定资源更高效。

include动作:例如jsp:include page="copyright.jsp"

/。该动作引入指定页面执行后生成的结果。由于它在运行时完成,因此对输出结果的控制更加灵活。但时,只有当被引用的内容频繁地改变时,或者在对主页面的请求没有出现之前,被引用的页面无法确定时,使用include动作才合算。

24、及时清除不再需要的会话

为了清除不再活动的会话,许多应用服务器都有默认的会话超时时间,一般为30分钟。当应用服务器需要保存更多会话时,如果内存容量不足,操作系统会把部分内存数据转移到磁盘,应用服务器也可能根据“最近最频繁使用”(Most

Recently

Used)算法把部分不活跃的会话转储到磁盘,甚至可能抛出“内存不足”异常。在大规模系统中,串行化会话的代价是很昂贵的。当会话不再需要时,应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。

25、不要将数组声明为:public static final 。

26、HashMap的遍历效率讨论

经常遇到对HashMap中的key和value值对的遍历操作,有如下两种方法:MapString, String[] paraMap = new HashMapString, String[]();

................//第一个循环

SetString appFieldDefIds = paraMap.keySet();

for (String appFieldDefId : appFieldDefIds) {

String[] values = paraMap.get(appFieldDefId);

......

}

//第二个循环

for(EntryString, String[] entry : paraMap.entrySet()){

String appFieldDefId = entry.getKey();

String[] values = entry.getValue();

.......

}

第一种实现明显的效率不如第二种实现。

分析如下 SetString appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet

代码如下:

public SetK keySet() {

SetK ks = keySet;

return (ks != null ? ks : (keySet = new KeySet()));

}

private class KeySet extends AbstractSetK {

public IteratorK iterator() {

return newKeyIterator();

}

public int size() {

return size;

}

public boolean contains(Object o) {

return containsKey(o);

}

public boolean remove(Object o) {

return HashMap.this.removeEntryForKey(o) != null;

}

public void clear() {

HashMap.this.clear();

}

}

其实就是返回一个私有类KeySet, 它是从AbstractSet继承而来,实现了Set接口。

再来看看for/in循环的语法

for(declaration : expression_r)

statement

在执行阶段被翻译成如下各式

for(IteratorE #i = (expression_r).iterator(); #i.hashNext();){

declaration = #i.next();

statement

}

因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator() 而这个方法调用了newKeyIterator()

IteratorK newKeyIterator() {

return new KeyIterator();

}

private class KeyIterator extends HashIteratorK {

public K next() {

return nextEntry().getKey();

}

}

所以在for中还是调用了

在第二个循环for(EntryString, String[] entry : paraMap.entrySet())中使用的Iterator是如下的一个内部类

private class EntryIterator extends HashIteratorMap.EntryK,V {

public Map.EntryK,V next() {

return nextEntry();

}

}

此时第一个循环得到key,第二个循环得到HashMap的Entry

效率就是从循环里面体现出来的第二个循环此致可以直接取key和value值

而第一个循环还是得再利用HashMap的get(Object key)来取value值

现在看看HashMap的get(Object key)方法

public V get(Object key) {

Object k = maskNull(key);

int hash = hash(k);

int i = indexFor(hash, table.length); //Entry[] table

EntryK,V e = table;

while (true) {

if (e == null)

return null;

if (e.hash == hash eq(k, e.key))

return e.value;

e = e.next;

}

}

其实就是再次利用Hash值取出相应的Entry做比较得到结果,所以使用第一中循环相当于两次进入HashMap的Entry中

而第二个循环取得Entry的值之后直接取key和value,效率比第一个循环高。其实按照Map的概念来看也应该是用第二个循环好一点,它本来就是key和value的值对,将key和value分开操作在这里不是个好选择。

java代码帮忙注释下!O(∩_∩)O谢谢要考试了,不懂啊!可以的话每段后面注释下!

import java.awt.*;

import javax.swing.*;

import java.awt.event.*;

import javax.swing.event.*;

/**

* 继承JFrame 实现 MouseMotionListener,ActionListener

*

*/

public class Exe10_1 extends JFrame implements MouseMotionListener,

ActionListener {

JLabel tracer;//声明一个JLabel

JButton start;//声明一个JButton

boolean tracing = true;// 定义一个Boolean变量

/**

* 构造函数

*/

public Exe10_1() {

super("鼠标跟踪");//设置JFrame的title

setBounds(300, 300, 300, 300); // JFrame大小

setLayout(new FlowLayout()); //JFrame的布局为FlowLayout

tracer = new JLabel();//给刚才声明的JLabel赋值

tracer.setPreferredSize(new Dimension(100, 30));//

tracer.setBackground(Color.blue);//设置背景色

tracer.setForeground(Color.white);//设置前景色

tracer.setOpaque(true);

addMouseMotionListener(this);//整个JFrame监听鼠标事件

add(tracer); //JFrame添加JLabel

start = new JButton("停止跟踪");//Jbutton初始化的名字为“停止跟随”

start.addActionListener(this);//JButton添加监听事件

add(start);//JFrame添加JLabel

setVisible(true);//JFrame的可见性

setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//右上角的【关闭】按钮

}

/* (当按下鼠标 不放开时 滑动鼠标 JLabel上打印内容)

* @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)

*/

public void mouseDragged(MouseEvent e) {

tracer.setText("(x,y) = (" + e.getX() + "," + e.getY() + ")");

}

/* (鼠标在JFrame上滑动时 JLabel上打印内容)

* @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)

*/

public void mouseMoved(MouseEvent e) {

tracer.setText("(x,y) = (" + e.getX() + "," + e.getY() + ")");

}

/* (鼠标监听事件处理)

* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)

*/

public void actionPerformed(ActionEvent e) {

if (tracing == true) {

removeMouseMotionListener(this);//JFrame移除监听鼠标事件

start.setText("继续跟踪");//JLabel重新设置Text

tracing = false;

} else {

addMouseMotionListener(this);//JFrame添加鼠标事件监听

start.setText("停止跟踪");//JLabel重新设置Text

tracing = true;

}

}

/** 程序入口

* @param args

*/

public static void main(String[] args) {

Exe10_1 frame = new Exe10_1();//生成一个Exe10_1的实例 实例名为:frame

}

}

希望对你有帮助


本文名称:java抢标代码 java抢购
URL网址:http://myzitong.com/article/ddiidcj.html