直接写递归方法了：
public boolean check(String s, char c){
if(1==s.length()){
return s.charAt(0) == c;
}
else{
return check(s.subString(1,s.length()), c);
}
㈡ 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算法，判断年月的连续性
看不明白，同年的话就是每个月都是连续的么？
不同年的呢，？
2050-12特殊年月是何意？
publicstaticbooleanfindThree(String[]years){
booleanflag=false;
all:for(inti=0;i<years.length;i++){
intnum=0;
for(intj=0;j<years.length;j++){
if(years[i].equals(years[j]))
num++;
if(num==3)
flag=true;
breakall;
}
}
returnflag;
}
publicstaticbooleantabCheck(String[]years){
//System.out.println(years[i].substring(0,4));
booleanflag=false;
for(inti=0;i<years.length-1;i++){
System.out.println(years[i].substring(0,4));
System.out.println(years[i].substring(6,7));
if(years[i].substring(0,4).equals(years[i+1].substring(0,4))
&&Integer.valueOf(years[i+1].substring(6,7))
-Integer.valueOf(years[i].substring(6,7))>1)
flag=true;
break;
}
returnflag;
}
publicstaticvoidmain(String[]args){
String[]years={"2012-01","2012-04","2012-05","2012-06","2012-07","2050-12"};
if(tabCheck(years)||findThree(years))
System.out.println("不合格");
else
System.out.println("合格");
}
//////////////////////////////////////////////////////////////////////
//如果只有两组年月的话，只有两种情况了，一种是同年隔一月，
//一种是隔年首尾相接
publicbooleanIsNext(String[]years){
Arrays.sort(years);
if(years[0].substring(0,4).equals(years[1].substring(0,4))){
if(Integer.valueOf(years[1].substring(6,7))-Integer.valueOf(years[0].substring(6,7))==1)
returntrue;
}elseif(Integer.valueOf(years[1].substring(0,4))-Integer.valueOf(years[0].substring(0,4))==1&&
Integer.valueOf(years[0].substring(6,7))==12&&Integer.valueOf(years[1].substring(6,7))==1){
returntrue;
}
returnfalse;
}
㈣ java常见gc算法有哪些
1：标记—清除
Mark-Sweep
过程：标记可回收对象，进行清除
缺点：标记和清除效率低，清除后会产生内存碎片
2：复制算法
过程：将内存划分为相等的两块，将存活的对象复制到另一块内存，把已经使用的内存清理掉
缺点：使用的内存变为了原来的一半
进化：将一块内存按8:1的比例分为一块Eden区（80%）和两块Survivor区（10%）
每次使用Eden和一块Survivor，回收时，将存活的对象一次性复制到另一块Survivor上，如果另一块Survivor空间不足，则使用分配担保机制存入老年代
3：标记—整理
Mark—Compact
过程：所有存活的对象向一端移动，然后清除掉边界以外的内存
4：分代收集算法
过程：将堆分为新生代和老年代，根据区域特点选用不同的收集算法，如果新生代朝生夕死，则采用复制算法，老年代采用标记清除，或标记整理
面试的话说出来这四种足够了
㈤ 求Java常用算法和经典算法
java.util.Arrays中包含了很多算法你可以看一看，jdk安装的时候就有提供源代码的。
㈥ 求java识别三角形，圆形，方形的具体算法和原理。
首先图片的背景和图形的颜色肯定是不一样的，图片是由像素组成的（这个概念很重要），，第一步区分背景和图形的颜色，保存背景的颜色，，第二步创建一个二维数组，这个二维数组对应于这个图片，你比如说，我这个图片是10*10大小的，然后我就把我这个数组保存是100*100的，即每隔0.1我取一下图片的像素值，判断这个像素值和背景是否一样，如果一样，那么数组的对应位置就存储0，否则存储1，，，第三步，通过Java代码控制鼠标遍历图片，一行一行的遍历，取像素值，与背景的像素对比，存入数组，遍历之后二维数组就只是存储的0和1(0代表背景，1代表图形)，，第四步，把所有为1的二维数组元素对应的坐标取出来，写个方法判断一下，相当于数轴知道X和Y了，你判断一下图形的形状，应该不难。。。而且图形就三个，，不难实现，，楼主可以试试
㈦ 利用Java判断一个数是否是素数的算法
//利用Java判断一个数是否是素数的算法
boolean f(int a){
boolean ean = true;
for(int i=2;i< Math.sqrt(a);i++){ //Math.sqrt 是调用Math类中的sqrt方法，求一个数的平方根
if(a%i==0){
ean = false;
break;
}
}
return ean;
}
㈧ 在Java中，设计一个算法,判断一个算术表达式中的括号是否配对。
算法：
String str="5+(4-3)）" 表达式
char kuohao[]; 用作括号堆栈
扫描str中的字符
1如果是（则入栈
2如果是）
a如果战不空出栈
b如果栈空，不匹配。算法结束
最后栈空则匹配
下面是我的实现
public class biaodashi {
public static void main(String args[])
{
int top=0;//堆指针
boolean end=true;//不匹配时只输出一次
char stack[]=new char[100];//存括号
String biaoda="(((1+(2)-6))";//表达式
char biao[]=biaoda.toCharArray();//将字符串转化成字符数组
System.out.println("表达式: "+biaoda);
for(int i=0;i<biao.length&&end;i++)//遍历表达式中所有字符
{
if(biao[i]=='(')//如果是(则入栈
{
stack[top]='(';
top++;
}
else if(biao[i]==')')//如果是)则出战
{
if(!(top==0))
top--;
else
{
System.out.println("括号不匹配");
end=false;
}
}
}//除循环两种可能
if(top==0&&end)
System.out.println("括号匹配");//出循环stack空
else if(top!=0&&end)
System.out.println("括号不匹配");//出循环时stack不空
}
}
㈨ 求 关于java 密码判断的一个算法
可以考虑把每个字符加入一个set里面(借助set的不重复特性)
最后检测set.length，如果为>6，那么就符合，否则false
伪代码如下
1）Integer.parseInt()如果能成功，就说明全部为数字，出错
2）加入set,
Set<String> set = new TreeSet<String>();
for(char item:password){
set.add(item);
3)判断set.size == str.length??相等，说明没有重复的字符，不相等说明有一部分重复了，失败
完整代码如下所示：
import java.util.Set;
import java.util.TreeSet;
public class Validator {
public static void main(String[] args) {
String password = "123456aa";
validatePassword(password);
}
private static boolean validatePassword(String password) {
if(password.length() < 6){
System.out.println("Password is too short");
return false;
}
try{
Integer.parseInt(password);
System.out.println("Password can't be all digits!");
return false;
}catch(NumberFormatException nbFmtExp){
Set<String> set = new TreeSet<String>();
char[] pwdArray = password.toCharArray();
for(int i = 0, len = pwdArray.length; i < len; i++){
if(!set.contains(String.valueOf(pwdArray[i]))){
set.add(String.valueOf(pwdArray[i]));
}
}
if(set.size() != password.length()){
System.out.println("Password contains plicate charactor!");
return false;
}
return true;
}
}
}
㈩ java中的算法，一共有多少种，哪几种，怎么分类。
就好比问，汉语中常用写作方法有多少种，怎么分类。
算法按用途分,体现设计目的、有什么特点
算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等
算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等
作为图灵完备的语言，理论上”Java语言“可以实现所有算法。
“Java的标准库'中用了一些常用数据结构和相关算法.
像apache common这样的java库中又提供了一些通用的算法