本文目录
- 用java实现des算法
- java有哪些垃圾回收算法
- 用java写人脸识别算法有哪些
- Java实现通用组合算法
- java常见gc算法有哪些
- 数据结构 java开发中常用的排序算法有哪些
- 分享Java常用几种加密算法
- java中的算法，一共有多少种，哪几种，怎么分类
用java实现des算法
分类: 电脑/网络 》》 程序设计 》》 其他编程语言 问题描述: 各位好，请求各位java学习者帮助钉解决这个问题。 我想用des算法对我的名字进行加密 我也在网上下载了des算法，包括FileDES,SubKey,Des各程序， 可能没真正理解这些程序，所以我想调用都不知道将这些东西组合起来，有知道的请帮帮忙啊！ 解析: package des; import java.io.*; import java.nio.*; import java.nio.channels.FileChannel; public class FileDES{ private static final boolean enc=true; 加密 private static final boolean dec=false; 解密 private String srcFileName; private String destFileName; private String inKey; private boolean actionType; private File srcFile; private File destFile; private Des des; private void *** yzePath(){ String dirName; int pos=srcFileNamestIndexOf("/"); dirName=srcFileName.substring(0,pos); File dir=new File(dirName); if (!dir.exists()){ System.err.println(dirName+" is not exist"); System.exit(1); }else if(!dir.isDirectory()){ System.err.println(dirName+" is not a directory"); System.exit(1); } pos=destFileNamestIndexOf("/"); dirName=destFileName.substring(0,pos); dir=new File(dirName); if (!dir.exists()){ if(!dir.mkdirs()){ System.out.println ("can not creat directory:"+dirName); System.exit(1); } }else if(!dir.isDirectory()){ System.err.println(dirName+" is not a directory"); System.exit(1); } } private static int replenish(FileChannel channel,ByteBuffer buf) throws IOException{ long byteLeft=channel.size()-channel.position(); if(byteLeft==0L) return -1; buf.position(0); buf.limit(buf.position()+(byteLeft《8 ? (int)byteLeft :8)); return channel.read(buf); } private void file_operate(boolean flag){ des=new Des(inKey); FileOutputStream outputFile=null; try { outputFile=new FileOutputStream(srcFile,true); }catch (java.io.FileNotFoundException e) { e.printStackTrace(System.err); } FileChannel outChannel=outputFile.getChannel(); try{ if(outChannel.size()%2!=0){ ByteBuffer bufTemp=ByteBuffer.allocate(1); bufTemp.put((byte)32); bufTemp.flip(); outChannel.position(outChannel.size()); outChannel.write(bufTemp); bufTemp.clear(); } }catch(Exception ex){ ex.printStackTrace(System.err); System.exit(1); } FileInputStream inFile=null; try{ inFile=new FileInputStream(srcFile); }catch(java.io.FileNotFoundException e){ e.printStackTrace(System.err); System.exit(1); } outputFile=null; try { outputFile=new FileOutputStream(destFile,true); }catch (java.io.FileNotFoundException e) { e.printStackTrace(System.err); } FileChannel inChannel=inFile.getChannel(); outChannel=outputFile.getChannel(); ByteBuffer inBuf=ByteBuffer.allocate(8); ByteBuffer outBuf=ByteBuffer.allocate(8); try{ String srcStr; String destStr; while(true){ if (replenish(inChannel,inBuf)==-1) break; srcStr=((ByteBuffer)(inBuf.flip())).asCharBuffer().toString(); inBuf.clear(); if (flag) destStr=des.enc(srcStr,srcStr.length()); else destStr=des.dec(srcStr,srcStr.length()); outBuf.clear(); if (destStr.length()==4){ for (int i = 0; i《4; i++) { outBuf.putChar(destStr.charAt(i)); } outBuf.flip(); }else{ outBuf.position(0); outBuf.limit(2*destStr.length()); for (int i = 0; i《destStr.length(); i++) { outBuf.putChar(destStr.charAt(i)); } outBuf.flip(); } try { outChannel.write(outBuf); outBuf.clear(); }catch (java.io.IOException ex) { ex.printStackTrace(System.err); } } System.out.println (inChannel.size()); System.out.println (outChannel.size()); System.out.println ("EoF reached."); inFile.close(); outputFile.close(); }catch(java.io.IOException e){ e.printStackTrace(System.err); System.exit(1); } } public FileDES(String srcFileName,String destFileName,String inKey,boolean actionType){ this.srcFileName=srcFileName; this.destFileName=destFileName; this.actionType=actionType; *** yzePath(); srcFile=new File(srcFileName); destFile=new File(destFileName); this.inKey=inKey; if (actionType==enc) file_operate(enc); else file_operate(dec); } public static void main(String args){ String file1=System.getProperty("user.dir")+"/111.doc"; String file2=System.getProperty("user.dir")+"/222.doc"; String file3=System.getProperty("user.dir")+"/333.doc"; String passWord="1234ABCD"; FileDES fileDes=new FileDES(file1,file2,passWord,true); FileDES fileDes1=new FileDES(file2,file3,passWord,false); }
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写人脸识别算法有哪些
Java中常见的人脸识别算法有：
Eigenface: 这是一种基于主成分分析的人脸识别算法，它将人脸图像映射到一个低维的特征空间。
Fisherface: 这是一种基于投影的人脸识别算法，它利用线性判别分析技术对人脸图像进行分类。
Local Binary Patterns (LBP): 这是一种基于二进制像素点比较的人脸识别算法，它提取了图像中的纹理特征。
Haar-like特征： 这是一种基于积分图像的人脸识别算法，它检测图像中的边缘特征。
Convolutional Neural Networks (CNNs): 这是一种基于卷积神经网络的人脸识别算法，它模拟了人类大脑中的视觉识别过程。
这些算法都是广泛用于人脸识别应用中的，根据具体需求和应用环境选择合适的算法是很重要的。
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 = * ;}}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左右
上述算法实现主要是针对两种条件进行实现的 即
第一个是完全数字字符串 ——》 带有*号的组合数字字符串
第二个带有*号的组合数字字符串 ——》 在该基础上继续组合得到带有*号的组合数字字符串
lishixinzhi/Article/program/Java/hx/201311/25538
java常见gc算法有哪些
1：标记—清除 Mark-Sweep过程：标记可回收对象，进行清除缺点：标记和清除效率低，清除后会产生内存碎片2：复制算法过程：将内存划分为相等的两块，将存活的对象复制到另一块内存，把已经使用的内存清理掉缺点：使用的内存变为了原来的一半进化：将一块内存按8:1的比例分为一块Eden区（80%）和两块Survivor区（10%）每次使用Eden和一块Survivor，回收时，将存活的对象一次性复制到另一块Survivor上，如果另一块Survivor空间不足，则使用分配担保机制存入老年代3：标记—整理 Mark—Compact过程：所有存活的对象向一端移动，然后清除掉边界以外的内存4：分代收集算法过程：将堆分为新生代和老年代，根据区域特点选用不同的收集算法，如果新生代朝生夕死，则采用复制算法，老年代采用标记清除，或标记整理面试的话说出来这四种足够了
数据结构 java开发中常用的排序算法有哪些
排序算法有很多，所以在特定情景中使用哪一种算法很重要。为了选择合适的算法，可以按照建议的顺序考虑以下标准： （1）执行时间 （2）存储空间 （3）编程工作 对于数据量较小的情形，（1）（2）差别不大，主要考虑（3）；而对于数据量大的，（1）为首要。 主要排序法有： 一、冒泡（Bubble）排序——相邻交换 二、选择排序——每次最小/大排在相应的位置 三、插入排序——将下一个插入已排好的序列中 四、壳（Shell）排序——缩小增量 五、归并排序 六、快速排序 七、堆排序 八、拓扑排序 一、冒泡（Bubble）排序 ----------------------------------Code 从小到大排序n个数------------------------------------ void BubbleSortArray() { for(int i=1;i《n;i++) { for(int j=0;i《n-i;j++) { if(a)//比较交换相邻元素 { int temp; temp=a=temp; } } } } -------------------------------------------------Code------------------------------------------------ 效率 O（n²）,适用于排序小列表。 二、选择排序 ----------------------------------Code 从小到大排序n个数-------------------------------- void SelectSortArray() { int min_index; for(int i=0;i《n-1;i++) { min_index=i; for(int j=i+1;j《n;j++)//每次扫描选择最小项 if(arr) min_index=j; if(min_index!=i)//找到最小项交换，即将这一项移到列表中的正确位置 { int temp; temp=arr=temp; } } } -------------------------------------------------Code----------------------------------------- 效率O（n²），适用于排序小的列表。 三、插入排序 --------------------------------------------Code 从小到大排序n个数------------------------------------- void InsertSortArray() { for(int i=1;i《n;i++)//循环从第二个数组元素开始，因为arr作为最初已排序部分 { int temp=arr;//temp标记为未排序第一个元素 int j=i-1; while (j》=0 && arr》temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/ { arr; j--; } arr=temp; } } ------------------------------Code-------------------------------------------------------------- 最佳效率O（n）；最糟效率O（n²）与冒泡、选择相同，适用于排序小列表 若列表基本有序，则插入排序比冒泡、选择更有效率。 四、壳（Shell）排序——缩小增量排序 -------------------------------------Code 从小到大排序n个数------------------------------------- void ShellSortArray() { for(int incr=3;incr《0;incr--)//增量递减，以增量3，2，1为例 { for(int L=0;L《(n-1)/incr;L++)//重复分成的每个子列表 { for(int i=L+incr;i《n;i+=incr)//对每个子列表应用插入排序 { int temp=arr; int j=i-incr; while(j》=0&&arr》temp) { arr; j-=incr; } arr=temp; } } } } --------------------------------------Code------------------------------------------- 适用于排序小列表。 效率估计O（nlog2^n）~O（n^1.5），取决于增量值的最初大小。建议使用质数作为增量值，因为如果增量值是2的幂，则在下一个通道中会再次比较相同的元素。 壳（Shell）排序改进了插入排序，减少了比较的次数。是不稳定的排序，因为排序过程中元素可能会前后跳跃。 五、归并排序 ----------------------------------------------Code 从小到大排序--------------------------------------- void MergeSort(int low,int high) { if(low》=high) return;//每个子列表中剩下一个元素时停止 else int mid=(low+high)/2;/*将列表划分成相等的两个子列表,若有奇数个元素，则在左边子列表大于右侧子列表*/ MergeSort(low,mid);//子列表进一步划分 MergeSort(mid+1,high); int ;//新建一个数组，用于存放归并的元素 for(int i=low,j=mid+1,k=low;i《=mid && j《=high;k++)/*两个子列表进行排序归并，直到两个子列表中的一个结束*/ { if (arr;) { B; I++; } else { B; j++; } } for( ;j《=high;j++,k++)//如果第二个子列表中仍然有元素，则追加到新列表 B; for( ;i《=mid;i++,k++)//如果在第一个子列表中仍然有元素，则追加到新列表中 B; for(int z=0;z《high-low+1;z++)//将排序的数组B的 所有元素复制到原始数组arr中 arr; } -----------------------------------------------------Code--------------------------------------------------- 效率O（nlogn），归并的最佳、平均和最糟用例效率之间没有差异。 适用于排序大列表，基于分治法。 六、快速排序 ------------------------------------Code-------------------------------------------- /*快速排序的算法思想：选定一个枢纽元素，对待排序序列进行分割，分割之后的序列一个部分小于枢纽元素，一个部分大于枢纽元素，再对这两个分割好的子序列进行上述的过程。*/ void swap(int a,int b){int t;t =a ;a =b ;b =t ;} int Partition(int arr,int low,int high) { int pivot=arr;//采用子序列的第一个元素作为枢纽元素 while (low 《 high) { //从后往前栽后半部分中寻找第一个小于枢纽元素的元素 while (low 《 high && arr 》= pivot) { --high; } //将这个比枢纽元素小的元素交换到前半部分 swap(arr); //从前往后在前半部分中寻找第一个大于枢纽元素的元素 while (low 《high &&arr 《=pivot ) { ++low ; } swap (arr );//将这个枢纽元素大的元素交换到后半部分 } return low ;//返回枢纽元素所在的位置 } void QuickSort(int a,int low,int high) { if (low 《high ) { int n=Partition (a ,low ,high ); QuickSort (a ,low ,n ); QuickSort (a ,n +1,high ); } } ----------------------------------------Code------------------------------------- 平均效率O（nlogn），适用于排序大列表。 此算法的总时间取决于枢纽值的位置；选择第一个元素作为枢纽，可能导致O（n²）的最糟用例效率。若数基本有序，效率反而最差。选项中间值作为枢纽，效率是O（nlogn）。 基于分治法。 七、堆排序 最大堆：后者任一非终端节点的关键字均大于或等于它的左、右孩子的关键字，此时位于堆顶的节点的关键字是整个序列中最大的。 思想： (1)令i=l,并令temp＝ kl ; (2)计算i的左孩子j=2i+1; (3)若j《＝n－1，则转(4),否则转(6); (4)比较kj和kj+1,若kj+1》kj,则令j＝j＋1，否则j不变； (5)比较temp和kj，若kj》temp，则令ki等于kj，并令i=j,j=2i+1,并转(3),否则转(6) (6)令ki等于temp，结束。 -----------------------------------------Code--------------------------- void HeapSort(SeqIAst R) { //对R可能违反堆性质 } } ---------------------------------------Code-------------------------------------- 堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。 堆排序的最坏时间复杂度为O(nlgn)。堆排序的平均性能较接近于最坏性能。 由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。 堆排序是就地排序，辅助空间为O(1)， 它是不稳定的排序方法。 堆排序与直接插入排序的区别: 直接选择排序中，为了从R中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。 堆排序可通过树形结构保存部分比较结果，可减少比较次数。 八、拓扑排序 例 ：学生选修课排课先后顺序 拓扑排序：把有向图中各顶点按照它们相互之间的优先关系排列成一个线性序列的过程。 方法： 在有向图中选一个没有前驱的顶点且输出 从图中删除该顶点和所有以它为尾的弧 重复上述两步，直至全部顶点均已输出（拓扑排序成功），或者当图中不存在无前驱的顶点（图中有回路）为止。 ---------------------------------------Code-------------------------------------- void TopologicalSort()/*输出拓扑排序函数。若G无回路，则输出G的顶点的一个拓扑序列并返回OK，否则返回ERROR*/ { int indegree; int i,k,j; char n; int count=0; Stack thestack; FindInDegree(G,indegree);//对各顶点求入度indegree InitStack(thestack);//初始化栈 for(i=0;i《G.num;i++) Console.WriteLine("结点"+G.vertices); for(i=0;i《G.num;i++) { if(indegree==0) Push(thestack.vertices); } Console.Write("拓扑排序输出顺序为："); while(thestack.Peek()!=null) { Pop(thestack.Peek()); j=locatevex(G,n); if (j==-2) { Console.WriteLine("发生错误，程序结束。"); exit(); } Console.Write(G.vertices.data); count++; for(p=G.vertices.firstarc;p!=NULL;p=p.nextarc) { k=p.adjvex; if (!(--indegree)) Push(G.vertices); } } if (count《G.num) Cosole.WriteLine("该图有环，出现错误，无法排序。"); else Console.WriteLine("排序成功。"); } ----------------------------------------Code-------------------------------------- 算法的时间复杂度O（n+e）。
分享Java常用几种加密算法
简单的Java加密算法有：第一种. BASEBase是网络上最常见的用于传输Bit字节代码的编码方式之一，大家可以查看RFC～RFC，上面有MIME的详细规范。Base编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base来将一个较长的唯一标识符（一般为-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。第二种. MDMD即Message-Digest Algorithm （信息-摘要算法），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD的前身有MD、MD和MD。广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD后都能生成唯一的MD值。好比现在的ISO校验，都是MD校验。怎么用？当然是把ISO经过MD后产生MD的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD的串。就是用来验证文件是否一致的。MD算法具有以下特点：压缩性：任意长度的数据，算出的MD值长度都是固定的。容易计算：从原数据计算出MD值很容易。抗修改性：对原数据进行任何改动，哪怕只修改个字节，所得到的MD值都有很大区别。弱抗碰撞：已知原数据和其MD值，想找到一个具有相同MD值的数据（即伪造数据）是非常困难的。强抗碰撞：想找到两个不同的数据，使它们具有相同的MD值，是非常困难的。MD的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。除了MD以外，其中比较有名的还有sha-、RIPEMD以及Haval等。第三种.SHA安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于^位的消息，SHA会产生一个位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。SHA-与MD的比较因为二者均由MD导出，SHA-和MD彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：对强行攻击的安全性：最显著和最重要的区别是SHA-摘要比MD摘要长 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD是^数量级的操作，而对SHA-则是^数量级的操作。这样，SHA-对强行攻击有更大的强度。对密码分析的安全性：由于MD的设计，易受密码分析的攻击，SHA-显得不易受这样的攻击。速度：在相同的硬件上，SHA-的运行速度比MD慢。第四种.HMACHMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。
java中的算法，一共有多少种，哪几种，怎么分类
就好比问，汉语中常用写作方法有多少种，怎么分类。算法按用途分,体现设计目的、有什么特点算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等作为图灵完备的语言，理论上”Java语言“可以实现所有算法。“Java的标准库’中用了一些常用数据结构和相关算法.像apache common这样的java库中又提供了一些通用的算法
