/**
* 希望能帮上你
* 有什么需要修改：请邮件[email protected]
*/
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class TestArray {
/**
* 第一组k[i]: 500,501,502 //球编号
第二组h[j]：500=1，502=1，500=2，502=3 / /球编号=几号箱子
if( 502==502))//两组的球编号匹配{
502-1 3
}
目标：匹配相同后，得到一个二维数组关系如下
500 1 2
502 1 3
问题补充：
匹配意义：如2组都有相同的编号，匹配后，摄入该编号属于的 箱子
*/
public static void main(String[] args) {
/**
* 球编号
*/
String[] ballNumbers={"500","501","502"};
/**
* 球与组号 的关系
*/
String[][] relations={
{"500","1"},
{"502","1"},
{"500","2"},
{"502","3"},
{"502","2"},
{"502","4"},
{"502","3"}};
/**
* 遍历 比较
*/
Map<String,String> resultMap=new HashMap<String,String>();
for(int i=0;i<ballNumbers.length;i++){
String ballNum=ballNumbers[i];
for(int j=0;j<relations.length;j++){
String key=relations[j][0];
String value=relations[j][1];
if(ballNum.equals(key)){
boolean exsits=resultMap.containsKey(ballNum);
if(exsits){
String val=resultMap.get(ballNum);
val=val+":"+value;
resultMap.put(ballNum, val);
}else{
resultMap.put(ballNum, value);
}
}
}
}
/**
* 打印结果 测试
*/
printResult(resultMap);
}
private static void printResult(Map<String, String> resultMap) {
Set<String> keys=resultMap.keySet();
for(String key:keys){
System.out.println(key+"="+resultMap.get(key));
}
}
}
② java中怎么快速的在很长的一串字符串中匹配一个一个字符串或者字符,不使用循环
假设你说的第一个字符串是A，第二个是B 判断A中是否有一个字符或者一段字符串包含于B中： boolean ifContrain = false; for(int i = 0 ; i < A.length - 1 ; i ++ ) { for(int j = i + 1 ; j < A.length ; j++ ) {
③ 如何用java实现多个字符串的快速匹配搜索
要判断boy是不是后者中的一部分，不用循环，只要用String类的indexOf函数就行了。
代码如下：
public class HH {
public static void main(String[] args) {
String s="he is a boy";
int result=s.indexOf("boy");
if(result>=0){
System.out.println("boy是he is a boy的一部分");
}else{
System.out.println("boy不是he is a boy的一部分");
}
}
}
运行结果：
boy是he is a boy的一部分
④ 求 JAVA 字符串匹配 完美算法
只需要实例化 类Matching 设置参数 并调用m.getIndex()方法就OK 请测试... public class Test18{
public static void main(String[] args){
Matching m = new Matching();
m.setOrgStr("ALSKLSHFKDLLS");
m.setSubStr("LS");
System.out.println(m.getIndex());
}
}
class Matching{
String orgStr ="";
String subStr ="";
public void setOrgStr(String orgStr){
this.orgStr = orgStr;
}
public void setSubStr(String subStr){
this.subStr = subStr;
}
public String getIndex(){
StringBuffer sb = new StringBuffer("{");
//根据关键字subStr来拆分字符串orgStr所得的字符串数组
String[] sub = orgStr.split(subStr);
int keyLength = subStr.length(); //关键字长度
int keySize = 0; //关键字个数
int subSize = sub.length; //子字符串个数
int subLength = 0; //子字符串长度
if(!orgStr.endsWith(subStr)){
keySize = subSize-1;
}else
keySize = subSize; int[] index = new int[keySize];//关键字下标数组
for(int i=0;i<keySize;i++){
subLength = sub[i].length();
if(i==0){
index[i]=subLength;
}else
index[i]=index[i-1]+subLength+keyLength;
}
if(keySize>0){
int l = keySize-1;
for(int i=0;i<l;i++){
sb.append(index[i]+",");
}
sb.append(index[l]);//最后一个关键字下标
}else{
sb.append("NULL");
}
sb.append("}");
return sb.toString();
}
}
⑤ java 超级简单 匹配算法问题，在线等（追加分数）
貌似这个必须要对每个都遍历的吧。本身并无规律可言，用二分法怎么用呢？
⑥ 多个方法具有同样的名称和相同数目的参数时，java编译器要确定如何匹配的算法步骤
方法同样名字和同样数目参数，需要看参数的类型匹配
如果是一个接口的方法，有不同的实现类，看使用的对象是谁
⑦ 求java全字替换算法、全字匹配算法
没做过，只是想到几个思路：
如果文本量比较少（几千或者上万，具体没有测试过）并且要查询和替换的目标在正则中不是很复杂的话，使用正则表达式就可以实现快速的文本的查找和替换，并不需要自己写算法。如果文本量很大，就需要自己再想办法了。
如果文本量比较大，可以将文本存储到数据库中，数据库提供了文本的查找和替换的功能，并 且此功能已经相当完善，调用相应的数据库函数可以实现查找和替换。
如果你只是想学习文字处理上的一些算法，而非实现查找和替换的功能的话，就当上面什么都没说好了.....
⑧ java的权重匹配算法技术求教
网站权重其实是指网络
而网络权重就是指网站获取流量的能力.根据你网站获取流量的能力来划分权重等级.下面给出的就根据流量的多少来划分权重的数据.
网络预计流量1~99 权重1
网络预计流量100~499 权重2
网络预计流量500~999 权重3
网络预计流量1000~4999 权重4
网络预计流量5000~9999 权重5
网络预计流量10000~49999 权重6
网络预计流量50000~199999 权重7
网络预计流量200000~999999 权重8
网络预计流量1000000以上 权重9”
另外要说的 就是网络权重是第三方根据研究网络的出来的结论.网络自身是没有这个说法的.
⑨ 用JAVA实现快速排序算法
public void quickSort(int left,int right,int a[])
{
int l=left;
int r=right;
int pivot=a[(l+r)/2];//转轴数
int temp=0;
while(l<r)
{
while(a[l]<pivot)l++;
while(a[r]>pivot)r--;
if(l>=r)break;
temp=a[l];
a[l]=a[r];
a[r]=temp;
if(a[l]==pivot)r--;
if(a[r]==pivot)l++;
}
if(l==r)
{
l++;
r--;
}
if(left<r)quickSort(left,r,a);
if(right>l)quickSort(l,right,a);
}
⑩ 快速查找算法 具体文字描述 附java程序更好 拜托各位了
快速查找算法 有叫做二分发，前提是必须对有序数组中的元素进行递归查找， 首先假设目标在数组中中间位置，与中间位置比较，如大于，则重左侧开始查找，如小于，则右侧开始查找，这样每次查找都能排除当前的一半，