java算法库

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

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

算法按用途分,体现设计目的、有什么特点
算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等
算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等

作为图灵完备的语言，理论上”Java语言“可以实现所有算法。
“Java的标准库'中用了一些常用数据结构和相关算法.

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

2. 用java写人脸识别算法有哪些

Java中常见的人脸识别算法有：

• Eigenface: 这是一种基于主成分分析的人脸识别算法，它将人脸图像映射到一个低维的特征空间。

• Fisherface: 这是一种基衡猜于卜拦乎投影的人脸识别算法，它利用线性判别分析技术对人脸图像进行分类。

• Local Binary Patterns (LBP): 这是一种基于二进制像素点比较的人脸识别算法，它提取了图像中的型悉纹理特征。

• Haar-like特征： 这是一种基于积分图像的人脸识别算法，它检测图像中的边缘特征。

• Convolutional Neural Networks (CNNs): 这是一种基于卷积神经网络的人脸识别算法，它模拟了人类大脑中的视觉识别过程。

这些算法都是广泛用于人脸识别应用中的，根据具体需求和应用环境选择合适的算法是很重要的。

3. Java简单算法问题

初步做了一个出来，但是效率并不是很高，前100个计算速度还可以，但是往后就很慢了。如果什么时候有空的话可以再看看，先给你代码吧，不知道能不能帮上你

publicclassAlisandaNumber{
	privatestaticfinalintMAX_INDEX=1000;//可以先把这个常量改为1-6，验证正确性
	publicstaticvoidmain(String[]args){
		inta=0;
		intindex=0;
		while(index<MAX_INDEX){
			a+=6;//每次循环自增6，由题目规律可知A是6的倍数
			booleanbreakOut=false;
			
			//最大的约数为此数的平方根，因为如果是两个平方根相乘的话，剩下的就只有1了
			intmaxNum=(int)Math.ceil(Math.sqrt(a));
			p:
			for(intp=1;p<=maxNum;p++){
				if(a%p!=0){
					continue;//如果不是约数的话，没必要考虑，下同
				}
				
				//最大约数为平方根的相反数，原理同上
				maxNum=(int)Math.ceil(Math.sqrt(a/p));
				for(intq=-1;q>=-maxNum;q--){//q和r必为负数
					if(a%q!=0){
						continue;
					}
					
					intr=a/(p*q);
					intnonZero=p*q+p*r+q*r;
					if(nonZero==0){
						continue;
					}
					if((a==p*q*r)&&(a==(p*q*r)/(nonZero))){
						index++;
						breakOut=true;
						breakp;//跳出外层循环
					}
				}
			}
			if(breakOut){
				System.out.println(String.format("第%d个压力山大数是%d",index,a));
			}
		}
	}
}

4. java实现几种常见排序算法

下面给你介绍四种常用排序算法：

1、冒泡排序

特点：效率低，实现简单

思想（从小到大排）：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。这只是冒泡排序的一种，当然也可以从后往前排。

5. Java算法设计：迭代器实现排序（求各位大佬各抒己见）

public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int e = arr.length - 1; e > 0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}
}

6. java常见gc算法有哪些

1：标记—清除 Mark-Sweep
过程：标记可回收对象，进行清除
缺点：标记和清除效率低，清除后会产生内存碎片
2：复制算法
过程：将内存划分为相等的两块，将存活的对象复制到另一块内存，把已经使用的内存清理掉
缺点：使用的内存变为了原来的一半
进化：将一块内存按8:1的比例分为一块Eden区（80%）和两块Survivor区（10%）
每次使用Eden和一块Survivor，回收时，将存活的对象一次性复制到另一块Survivor上，如果另一块Survivor空间不足，则使用分配担保机制存入老年代
3：标记—整理 Mark—Compact
过程：所有存活的对象向一端移动，然后清除掉边界以外的内存

4：分代收集算法
过程：将堆分为新生代和老年代，根据区域特点选用不同的收集算法，如果新生代朝生夕死，则采用复制算法，老年代采用标记清除，或标记整理
面试的话说出来这四种足够了

7. 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. 将另一序列剩下的所有元素

8. java数字图像处理常用算法

前些时候做毕业设计 用java做的数字图像处理方面的东西 这方面的资料ms比较少 发点东西上来大家共享一下 主要就是些算法 有自己写的 有人家的 还有改人家的 有的算法写的不好 大家不要见笑

一 读取bmp图片数据

// 获取待检测图像 数据保存在数组 nData[] nB[] nG[] nR[]中

public void getBMPImage(String source) throws Exception { clearNData(); //清除数据保存区 FileInputStream fs = null; try { fs = new FileInputStream(source); int bfLen = ; byte bf[] = new byte[bfLen]; fs read(bf bfLen); // 读取 字节BMP文件头 int biLen = ; byte bi[] = new byte[biLen]; fs read(bi biLen); // 读取 字节BMP信息头

// 源图宽度 nWidth = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 源图高度 nHeight = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 位数 nBitCount = (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 源图大小 int nSizeImage = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;

// 对 位BMP进行解析 if (nBitCount == ){ int nPad = (nSizeImage / nHeight) nWidth * ; nData = new int[nHeight * nWidth]; nB=new int[nHeight * nWidth]; nR=new int[nHeight * nWidth]; nG=new int[nHeight * nWidth];键带 byte bRGB[] = new byte[(nWidth + nPad) * * nHeight]; fs read(bRGB (nWidth + nPad) * * nHeight); int nIndex = ; for (int j = ; j < nHeight; j++){ for (int i = ; i < nWidth; i++) { nData[nWidth * (nHeight j ) + i] = ( & xff) << | (((int) bRGB[nIndex + ] & xff) << ) | (((int) bRGB[nIndex + ] & xff) << ) | (int) bRGB[nIndex] & xff; nB[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex]& xff; nG[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+ ]& xff; nR[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+ ]& xff;稿物芦 nIndex += ; } nIndex += nPad; }// Toolkit kit = Toolkit getDefaultToolkit();// image = kit createImage(new MemoryImageSource(nWidth nHeight // nData nWidth));

/*蚂册 //调试数据的读取

FileWriter fw = new FileWriter( C:\Documents and Settings\Administrator\My Documents\nDataRaw txt );//创建新文件 PrintWriter out = new PrintWriter(fw); for(int j= ;j<nHeight;j++){ for(int i= ;i<nWidth;i++){ out print(( * +nData[nWidth * (nHeight j ) + i])+ _ +nR[nWidth * (nHeight j ) + i]+ _ +nG[nWidth * (nHeight j ) + i]+ _ +nB[nWidth * (nHeight j ) + i]+ ); } out println( ); } out close();*/ } } catch (Exception e) { e printStackTrace(); throw new Exception(e); } finally { if (fs != null) { fs close(); } } // return image; }

二由r g b 获取灰度数组

public int[] getBrightnessData(int rData[] int gData[] int bData[]){ int brightnessData[]=new int[rData length]; if(rData length!=gData length || rData length!=bData length || bData length!=gData length){ return brightnessData; } else { for(int i= ;i<bData length;i++){ double temp= *rData[i]+ *gData[i]+ *bData[i]; brightnessData[i]=(int)(temp)+((temp (int)(temp))> ? : ); } return brightnessData; } }

三 直方图均衡化

public int [] equilibrateGray(int[] PixelsGray int width int height) { int gray; int length=PixelsGray length; int FrequenceGray[]=new int[length]; int SumGray[]=new int[ ]; int ImageDestination[]=new int[length]; for(int i = ; i <length ;i++) { gray=PixelsGray[i]; FrequenceGray[gray]++; } // 灰度均衡化 SumGray[ ]=FrequenceGray[ ]; for(int i= ;i< ;i++){ SumGray[i]=SumGray[i ]+FrequenceGray[i]; } for(int i= ;i< ;i++) { SumGray[i]=(int)(SumGray[i]* /length); } for(int i= ;i<height;i++) { for(int j= ;j<width;j++) { int k=i*width+j; ImageDestination[k]= xFF | ((SumGray[PixelsGray[k]]<< ) | (SumGray[PixelsGray[k]]<< ) | SumGray[PixelsGray[k]]); } } return ImageDestination; }

四 laplace 阶滤波 增强边缘 图像锐化

public int[] laplace DFileter(int []data int width int height){ int filterData[]=new int[data length]; int min= ; int max= ; for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i==height || j== || j==width ) filterData[i*width+j]=data[i*width+j]; else filterData[i*width+j]= *data[i*width+j] data[i*width+j ] data[i*width+j+ ] data[(i )*width+j] data[(i )*width+j ] data[(i )*width+j+ ] data[(i+ )*width+j] data[(i+ )*width+j ] data[(i+ )*width+j+ ]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } }// System out println( max: +max);// System out println( min: +min); for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } return filterData; }

五 laplace 阶增强滤波 增强边缘 增强系数delt

public int[] laplaceHigh DFileter(int []data int width int height double delt){ int filterData[]=new int[data length]; int min= ; int max= ; for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i==height || j== || j==width ) filterData[i*width+j]=(int)(( +delt)*data[i*width+j]); else filterData[i*width+j]=(int)(( +delt)*data[i*width+j] data[i*width+j ]) data[i*width+j+ ] data[(i )*width+j] data[(i )*width+j ] data[(i )*width+j+ ] data[(i+ )*width+j] data[(i+ )*width+j ] data[(i+ )*width+j+ ]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } return filterData; } 六 局部阈值处理 值化

// 局部阈值处理 值化 niblack s method /*原理 T(x y)=m(x y) + k*s(x y) 取一个宽度为w的矩形框 (x y)为这个框的中心 统计框内数据 T(x y)为阈值 m(x y)为均值 s(x y)为均方差 k为参数(推荐 )计算出t再对(x y)进行切割 / 这个算法的优点是 速度快 效果好 缺点是 niblack s method会产生一定的噪声 */ public int[] localThresholdProcess(int []data int width int height int w int h double coefficients double gate){ int[] processData=new int[data length]; for(int i= ;i<data length;i++){ processData[i]= ; } if(data length!=width*height) return processData; int wNum=width/w; int hNum=height/h; int delt[]=new int[w*h]; //System out println( w; +w+ h: +h+ wNum: +wNum+ hNum: +hNum); for(int j= ;j<hNum;j++){ for(int i= ;i<wNum;i++){ //for(int j= ;j< ;j++){ //for(int i= ;i< ;i++){ for(int n= ;n<h;n++) for(int k= ;k<w;k++){ delt[n*w+k]=data[(j*h+n)*width+i*w+k]; //System out print( delt[ +(n*w+k)+ ]: +delt[n*w+k]+ ); } //System out println(); /* for(int n= ;n<h;n++) for(int k= ;k<w;k++){ System out print( data[ +((j*h+n)*width+i*w+k)+ ]: +data[(j*h+n)*width+i*w+k]+ ); } System out println(); */ delt=thresholdProcess(delt w h coefficients gate); for(int n= ;n<h;n++) for(int k= ;k<w;k++){ processData[(j*h+n)*width+i*w+k]=delt[n*w+k]; // System out print( delt[ +(n*w+k)+ ]: +delt[n*w+k]+ ); } //System out println(); /* for(int n= ;n<h;n++) for(int k= ;k<w;k++){ System out print( processData[ +((j*h+n)*width+i*w+k)+ ]: +processData[(j*h+n)*width+i*w+k]+ ); } System out println(); */ } } return processData; }

七 全局阈值处理 值化

public int[] thresholdProcess(int []data int width int height double coefficients double gate){ int [] processData=new int[data length]; if(data length!=width*height) return processData; else{ double sum= ; double average= ; double variance= ; double threshold; if( gate!= ){ threshold=gate; } else{ for(int i= ;i<width*height;i++){ sum+=data[i]; } average=sum/(width*height); for(int i= ;i<width*height;i++){ variance+=(data[i] average)*(data[i] average); } variance=Math sqrt(variance); threshold=average coefficients*variance; } for(int i= ;i<width*height;i++){ if(data[i]>threshold) processData[i]= ; else processData[i]= ; } return processData; } }

八 垂直边缘检测 sobel算子

public int[] verticleEdgeCheck(int []data int width int height int sobelCoefficients) throws Exception{ int filterData[]=new int[data length]; int min= ; int max= ; if(data length!=width*height) return filterData; try{ for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i== || i==height || i==height ||j== || j== || j==width || j==width ){ filterData[i*width+j]=data[i*width+j]; } else{ double average; //中心的九个像素点 //average=data[i*width+j] Math sqrt( )*data[i*width+j ]+Math sqrt( )*data[i*width+j+ ] average=data[i*width+j] sobelCoefficients*data[i*width+j ]+sobelCoefficients*data[i*width+j+ ] data[(i )*width+j ]+data[(i )*width+j+ ] data[(i+ )*width+j ]+data[(i+ )*width+j+ ]; filterData[i*width+j]=(int)(average); } if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } } catch (Exception e) { e printStackTrace(); throw new Exception(e); } return filterData; }

九 图像平滑 * 掩模处理（平均处理） 降低噪声

lishixin/Article/program/Java/hx/201311/26286

9. java有没有类似leftjoin的算法

Java的标准库里面没有类似这样的函数，不过你完全可以自己实现一携没镇个，提察纯高效辩粗率就用StringBuffer实现
import java.util.ArrayList;
import java.util.List;

public class StringBuilderDemo1 {

public static String join(String join,String[] strAry){
StringBuffer sb=new StringBuffer();
for(int i=0;i<strAry.length;i++){
if(i==(strAry.length-1)){
sb.append(strAry[i]);
}else{
sb.append(strAry[i]).append(join);
}
}

return new String(sb);
}

public static void main(String[] args){

String[] sa={"a","b","c"};
String s1=StringBuilderDemo1.join("-",sa);
System.out.println(s1);

}
}

10. java算法有哪些分别

您好：

java中的算法，常见的有：递归、迭代、查找、排序（包含冒泡排序、选择排序、插入排序、快速排序四种） 等，算法有很多，一般数据结构中涉及到的都可以用java语言实现。

举几个例子：

1.递归的例子：

不一一举例，仅供参考！