java算法大全(java中的算法,一共有多少种,哪几种,怎么分类。)

你是否想了解更多关于java算法大全和java中的算法,一共有多少种,哪几种,怎么分类。的知识？在本文中，小编将为您详细介绍这两个话题，帮助您更好地理解。

java中的算法,一共有多少种,哪几种,怎么分类。

就好比问，汉语中常用写作方法有多少种，怎么分类。

算法按用途分,体现设计目的、有什么特点

算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等

算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等

作为图灵完备的语言，理论上”Java语言“可以实现所有算法。

“Java的标准库'中用了一些常用数据结构和相关算法.

像apache common这样的java库中又提供了一些通用的算法

java有哪些垃圾回收算法

常用的垃圾回收算法有：

(1).引用计数算法：

给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不再被使用的，垃圾收集器将回收该对象使用的内存。

引用计数算法实现简单，效率很高，微软的COM技术、ActionScript、Python等都使用了引用计数算法进行内存管理，但是引用计数算法对于对象之间相互循环引用问题难以解决，因此java并没有使用引用计数算法。

(2).根搜索算法：

通过一系列的名为“GC Root”的对象作为起点，从这些节点向下搜索，搜索所走过的路径称为引用链(Reference Chain)，当一个对象到GC Root没有任何引用链相连时，则该对象不可达，该对象是不可使用的，垃圾收集器将回收其所占的内存。

主流的商用程序语言C#、java和Lisp都使用根搜素算法进行内存管理。

在java语言中，可作为GC Root的对象包括以下几种对象：

a. java虚拟机栈(栈帧中的本地变量表)中的引用的对象。

b.方法区中的类静态属性引用的对象。

c.方法区中的常量引用的对象。

d.本地方法栈中JNI本地方法的引用对象。

java方法区在Sun HotSpot虚拟机中被称为永久代，很多人认为该部分的内存是不用回收的，java虚拟机规范也没有对该部分内存的垃圾收集做规定，但是方法区中的废弃常量和无用的类还是需要回收以保证永久代不会发生内存溢出。

判断废弃常量的方法：如果常量池中的某个常量没有被任何引用所引用，则该常量是废弃常量。

判断无用的类：

(1).该类的所有实例都已经被回收，即java堆中不存在该类的实例对象。

(2).加载该类的类加载器已经被回收。

(3).该类所对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射机制访问该类的方法。

Java中常用的垃圾收集算法：

(1).标记-清除算法：

最基础的垃圾收集算法，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成之后统一回收掉所有被标记的对象。

标记-清除算法的缺点有两个：首先，效率问题，标记和清除效率都不高。其次，标记清除之后会产生大量的不连续的内存碎片，空间碎片太多会导致当程序需要为较大对象分配内存时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。

(2).复制算法：

将可用内存按容量分成大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另一块内存上去，然后把使用过的内存空间一次清理掉。这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。

复制算法的缺点显而易见，可使用的内存降为原来一半。

(3).标记-整理算法：

标记-整理算法在标记-清除算法基础上做了改进，标记阶段是相同的标记出所有需要回收的对象，在标记完成之后不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，在移动过程中清理掉可回收的对象，这个过程叫做整理。

标记-整理算法相比标记-清除算法的优点是内存被整理以后不会产生大量不连续内存碎片问题。

复制算法在对象存活率高的情况下就要执行较多的复制操作，效率将会变低，而在对象存活率高的情况下使用标记-整理算法效率会大大提高。

(4).分代收集算法：

根据内存中对象的存活周期不同，将内存划分为几块，java的虚拟机中一般把内存划分为新生代和年老代，当新创建对象时一般在新生代中分配内存空间，当新生代垃圾收集器回收几次之后仍然存活的对象会被移动到年老代内存中，当大对象在新生代中无法找到足够的连续内存时也直接在年老代中创建。

java十大算法

算法一：快速排序算法

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

算法步骤：

1从数列中挑出一个元素，称为"基准"（pivot），

2重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法二：堆排序算法

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序的平均时间复杂度为Ο(nlogn)。

算法步骤：

创建一个堆H[0..n-1]

把堆首（最大值）和堆尾互换

3.把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4.重复步骤2，直到堆的尺寸为1

算法三：归并排序

归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法步骤：

1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2.设定两个指针，最初位置分别为两个已经排序序列的起始位置

3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4.重复步骤3直到某一指针达到序列尾

5.将另一序列剩下的所有元素

Java实现通用组合算法

Java实现通用组合算法存在一个类似{}这样的集合经过取组合其他位置用非字母数字字符替代比如使用*号得到类似{******}这样的集合

现在有这样的需求

存在一个类似{}这样的集合经过取组合其他位置用非字母数字字符替代比如使用*号得到类似{******}这样的集合

还要求对于{******}这样的集合再次经过取组合其他位置用非字母数字字符替代比如使用*号得到类似{***************}这样的集合

对于这样的要求实现的思路如下

首先主要思想是基于信息编码原理通过扫描字符串将组合变为组合

其次对于每个数字字符串设置一个单线程在单线程类中设置一个List用来存放待处理数字字符串（可能含有*号或者不含有）中每个数字的（而非*号）索引位置值

再次设置BitSet来标志每个位置是否被*号替换得到新的组合字符串

最后在扫描原始待处理数字字符串的过程中根据设置的字符列表List中索引来操作BitSet对于每一个BitSet得到一个新的组合

使用Java语言实现如下

package shirdrn;import java util ArrayList;import java util BitSet;import java util Collection;import java util Collections;import java util HashSet;import java util Iterator;import java util List;/***通用组合拆分类(基于单线程)*可以完成两种功能*第一可以将完全数字串拆分成为含有*号的字符串*例如输入集合{} Splitter类会遍历该集合对每个字符串创建一个SplitterThread*线程来处理如果是取组合即starCount==经过线程处理得到类似************等结果*第二根据从带有*号的字符串经过拆分过滤后得到的字符串集合对其中每一个字符串进行组合*例如输入集合取组合字符串集合{******}* CommonSplitter类会遍历该集合对每个带有*号的字符串创建一个SplitterThread*线程来处理如果是串组合即starCount==经过线程处理得到类似************等结果*@author时延军*/public class CommonSplitter{private int starCount;private boolean duplicate;private Collection filteredContainer;public Collection getFilteredContainer(){return filteredContainer;}/***构造一个Spilitter实例*@param container输入的待处理字符串集合*@param starCount如果对于长度为N的数字字符串进行M组合(即N取M)则starCount=N M*@param duplicate是否去重*/public CommonSplitter(Collection container int starCount boolean duplicate){this duplicate= duplicate;this starCount= starCount;if(this duplicate){//根据指定是否去重的选择选择创建容器filteredContainer= Collections synchronizedSet(new HashSet());}else{filteredContainer= Collections synchronizedList(new ArrayList());}Iterator it= erator();while(it hasNext()){new Thread(new SplitterThread(it next() trim())) start();}try{Thread sleep();} catch(InterruptedException e){e printStackTrace();}}/***对一个指定的N场比赛的长度为N的单式投注字符串进行组合*输入单式投注注字符串string例如组合得到类似************结果的集合**@author时延军*/class SplitterThread implements Runnable{private char[] charArray;private int len;//数字字符的个数List occupyIndexList= new ArrayList();//统计字符串中没有带*的位置的索引private List container= new ArrayList();private BitSet startBitSet;//比特集合起始状态private BitSet endBitSet;//比特集合终止状态用来控制循环public SplitterThread(String string){this charArray= string toCharArray();this len= string replace(*) length();this startBitSet= new BitSet(len);this endBitSet= new BitSet(len);//初始化startBitSet左侧占满*符号int count=;//for(int i=; iif(charArray[i]!=*){if(count< starCount){this startBitSet set(i true);count++;}occupyIndexList add(i);}}//初始化endBit右侧占满*符号count=;for(int i= string length(); i>; i){if(charArray[i]!=*){if(count< starCount){this endBitSet set(i true);count++;}ccupyIndexList add(i);}}//根据起始startBitSet构造带*的组合字符串并加入容器char[] charArrayClone= this charArray clone();for(int i=; iif(this startBitSet get(i)){charArrayClone[i]=*;}}ntainer add(new String(charArrayClone));}public void run(){this split();synchronized(filteredContainer){filteredContainer addAll(ntainer);}}public void split(){while(!this startBitSet equals(this endBitSet)){int zeroCount=;//统计遇到后左边的个数int oneCount=;//统计遇到后左边的个数int pos=;//记录当前遇到的索引位置char[] charArrayClone= this charArray clone();//遍历startBitSet来确定出现的位置for(int i=; iif(!this startBitSet get(this occupyIndexList get(i))){zeroCount++;}if(this startBitSet get(this occupyIndexList get(i))&&!this startBitSet get(this occupyIndexList get(i+))){pos= i;oneCount= i zeroCount;//将变为 this startBitSet set(this occupyIndexList get(i) false);this startBitSet set(this occupyIndexList get(i+) true);break;}}//将遇到后左侧的全部移动到最左侧int count= Math min(zeroCount oneCount);int startIndex= this occupyIndexList get();int endIndex=;if(pos>&& count>){pos;endIndex= this occupyIndexList get(pos);for(int i=; ithis startBitSet set(startIndex true);this startBitSet set(endIndex false);startIndex= this occupyIndexList get(i+);pos;if(pos>){endIndex= this occupyIndexList get(pos);}}}//将遇到的位置用*替换for(int i=; iif(this startBitSet get(this occupyIndexList get(i))){charArrayClone[this occupyIndexList get(i)]=*;}}ntainer add(new String(charArrayClone));}}}}

测试用例如下所示

package shirdrn;import java util ArrayList;import java util Collection;import junit framework TestCase;import shirdrn util GoodTools;public class TestCommonSplitter extends TestCase{private CommonSplitter splitter;public void setSplitter(Collection container int starCount boolean duplicate){this splitter= new CommonSplitter(container starCount duplicate);}public void testSplliter(){Collection container= new ArrayList();container add(***);int starCount=;boolean duplicate= true;this setSplitter(container starCount duplicate);System out println(this splitter getFilteredContainer());}public void testSplliter(){Collection container= new ArrayList();container add(***);int starCount=;boolean duplicate= true;this setSplitter(container starCount duplicate);System out println(this splitter getFilteredContainer());assertEquals( this splitter getFilteredContainer() size());}public void testNoStar(){Collection container= new ArrayList();container add();int starCount=;boolean duplicate= true;this setSplitter(container starCount duplicate);System out println(this splitter getFilteredContainer());assertEquals( this splitter getFilteredContainer() size());}public void testSplitter_ _(){//场: String multiSeq=;Collection container= GoodTools getNSingleList(multiSeq);assertEquals( container size());int starCount=;boolean duplicate= false;this setSplitter(container starCount duplicate);assertEquals( this splitter getFilteredContainer() size());}}上述测试耗时大约 s左右

上述算法实现主要是针对两种条件进行实现的即

第一个是完全数字字符串——>带有*号的组合数字字符串

第二个带有*号的组合数字字符串——>在该基础上继续组合得到带有*号的组合数字字符串

关于java算法大全的内容到此结束，希望对大家有所帮助。