字符串长度的计算
(1)计算字符串长度时关键是要注意辨认转义字符；(2)一个转义字符总是以反斜杠开始，再加一个其他字符组成。所以，遇到反斜杠时要特别注意！！！
1、不带转义字符的字符串
　　如：”abc!x=/”,其长度为 7
2、带转义字符的字符串
　　(1) 字符串”abc\n”：其中的’\n’为转义字符（换行符），计算字符串长度时只能计作一个字符，所以该字符串的长度为4（而不是5）
　　(2) 字符串”abc\n\\\’\”“：其中有4个转义字符：’\n’（换行符）、’\\’（反斜杠）、’\”（单引号）、’\”’（双引号），所以该字符串的长度为7（而不是11）。
　　(3) 字符串“abc\0xyz”：其中有一个转义字符’\0’，它是字符串结束符，所以，当用函数strlen来测试该字符串的长度时，结果应该为3（而不是7）。
　　(4) 字符串“abc\\0xy”：其中有一个转义字符’\\’（反斜杠），这样，后面的字符串“0xy”照样计算，所以，该字符串的长度为7（而不是将第二个反斜杠与其后的0结合为一个转义字符’\0’,若那样的话，第一个反斜杠将无法处理，因为一个转义字符总是由反斜杠加其他字符组成的，单独的一个反斜杠不能作为任何合法的字符）。
　　(5) 若将字符串“abc\\0xy”改为“abc\\\0xy”:则其中有二个转义字符’\’（反斜杠）和’\0’（字符串结束符），这时，当用函数strlen来测试该字符串的长度时，结果应该为4（而不是7）。
　　(6) 若将字符串“abc\\\0xy”改为“abc\\\061xy”:则其中有二个转义字符’\’（反斜杠）和’\061’（ASCII码值等于061的字符，也即数字字符’1’），这时，当用函数strlen来测试该字符串的长度时，结果应该为7（而不是4或9）。所以，当遇到转义字符’\0’时，还要看其后面是否还有数字，若有，则应将后面的数字（一至二位）与前面的’\0’相结合作为一个字符计入整个字符串的长度。
　　　若用printf(“abc\\\061xy”)；输出结果为：abc\1xy
　　(7)printf(“\x69\082\n”);输出结果为：i
　　 sizeof(“\x69\082\n”)结果为6
\x69为十六进制的69,十进制105对应字母i，而\0xx是八进制，但八进制只有数字0-7，\082显然不是。

字符串的比较
1. C中的char[]

#include <string.h>

char s1[10],s2[10]; 
... 
if(strcmp(s1,s2)==0) 
    printf("两字符串相等\n");
//string.h 头文件中就有比较函数,可以用来比较是否相等

C语言中为什么两个字符串不能直接进行比较？
有如下代码：

char s1[] = "abc";
char s2[] = "abc";

//如果直接进行比较：
if (s1 == s2)
{
printf("s1等于 s2");
}
else
{
printf("s1 不等于s2");
}

大家想想输出结果会是什么呢？

输出结果永远为：s1 不等于 s2.(不论你换成char s1[] = “abc”; char s2[] = “def”; 还是char s1[] = “def”; char s2[] = “abc”;,输出结果都一样）。

为什么呢？
大家因为这样比较，其实是在把s1和s2当作指针来进行比较，而不是比较两个数组中的内容。因为s1和s2在内存中位置肯定不同，所以s1 == s2的值肯定为0，所以出现上面的结果也就是理所当然了。
这个应该可以追溯到C语言中 数组（字符串也可认为是数组）的访问机制

2.C++中string字符串比较

#include <iostream>
#include <string>
using namespace std;
int main()
{
    char a1[] = "abc";
    char a2[] = "abc";
    char a3[] = "abbc";
    if(a1 == a2)                    //a1 != a2
        printf("a1 = a2\n");
    else
        printf("a1 != a2\n");
    if(0 == strcmp(a1, a2))         //a1 = a2
        printf("a1 = a2\n");
    else
        printf("a1 != a2\n");
    if(strcmp(a2, a3)>0)            //a2 > a3
        printf("a2 > a3\n");

    string s1 = "abc";
    string s2 = a1;
    string s3 = "abbc";
    if(s1 == s2)                    //s1 = s2
        printf("s1 = s2\n");
    if(s1 == a1)                    //s1 = a1
        printf("s1 = a1\n");
    if(s2>s3)                       //s2 > s3
        printf("s2 > s3\n");


    return 0;
}

字符串比较

比较两个字符串指针：如果两个字符串相等，返回0

• strcmp(区分大小写) //多字节
• stricmp(不区分大小写) //多字节
• wcscmp(区分大小写) //宽字节
• wcsicmp(不区分大小写) //宽字节
• _tcscmp();(区分大小写) //多字节宽字节皆可
• _tcsicmp();(不区分大小写) //多字节宽字节皆可
• CString::Compare();（区分大小写）
• CString::CompareNoCase();（不区分大小写）

int wcscmp(
   const wchar_t *string1,
   const wchar_t *string2
);

int wcsicmp(
	 const wchar_t * _Str1,
	 const wchar_t * _Str2
);

字符串长度

• strlen(); //获取多字节字符串长度，不包含 ‘/0’。
• wcslen(); //获取宽字节字符串长度，不包含 ‘/0’。
• _tcslen() //获取宽字节和多字节字符串长度，不包含 ‘/0’。
• CString::GetLength();

size_t wcslen(
   const wchar_t *str
);

字符串拷贝

• strcpy(); //多字节字符串拷贝
• wcscpy(); //宽字节字符串拷贝
• _tcscpy(); //两者皆可字符串拷贝
• CString::operator =

wchar_t *wcscpy(
   wchar_t *strDestination,
   const wchar_t *strSource
);

字符串拼接

• strcat(); //多字节字符串拼接
• wcscat(); //宽字节字符串拼接
• _tcscat(); //两者皆可字符串拼接
• CString::operator +=

wchar_t *wcscat(
   wchar_t *strDestination,
   const wchar_t *strSource
);

字符串转换

USES_CONVERSION;//定义转换宏

T2A：wchar_t->char
A2T：char->wchar_t

1.背景介绍

今天在公司接到一个需求,大概是这样的.我们ERP系统数据库有张customer(客户)表,其中有个字段是小区名称(plotName),当初在录入数据时没有对这一字段做界定和规范,由人工手动录入,这就导致两位客户本是一个小区,而录入的小区名可能不是完全一样的结果.例如张三和李四都住在武林邸,而张三录入的数据是"武林邸",李四录入的数据的"杭州市西湖区武林邸",又或是舞林邸等.由于业务需要,现需要对这些小区名进行名称规整,如上述例子都规整为"杭州市西湖区武林邸".

2.解决方案如下

既然要规整,就要有统一的名称规范,最终决定从安居客,租房网等爬出杭州市各小区的标准名称.再用数据库现有数据与之对比.列出最相似的前三个名称,然后泽其一修数据库数据.

如下图所示:匹配度及为相似度算法计算所得结果.

3.难点

难点就是字符串相似度对比算法的设计,网上查阅大量资料,如字符串最小编辑距离匹配算法此处不适用,因为对比的字符串与目标字符串长度不一样,会导致对比结果不是正确的.用代码和数据验证如下:

对比的三个字符串如下:                                     目标字符串为:"龙悦湾金石院子"

1. "浙江省杭州市拱墅区龙悦湾金石院子"
2. "金石院子十六幢二单元302"
3. "金子"

 public static void main(String[] args){
        LinkedList list=new LinkedList();
        String source = "龙悦湾金石院子";//目标字符串
        String target1 = "浙江省杭州市拱墅区龙悦湾金石院子";
        String target2="金石院子十六幢二单元302";
        String target3="金子";
        System.out.println(target1+"最小编辑距离是："+minEdit_distance(source,target1));
        System.out.println(target2+"最小编辑距离是："+minEdit_distance(source,target2));
        System.out.println(target3+"最小编辑距离是："+minEdit_distance(source,target3));
    }

其中minEdit_distance()方法是最小编辑距离算法,根据此算法的思想,如果最小编辑距离值越小,则说明两个字符串越相似.而此处打印结果为9,12,5.即"金子"与"龙悦湾金石院子"最相似,"浙江省杭州市拱墅区龙悦湾金石院子"第二,"金石院子十六幢二单元302"第三,而实际应该是"金子"与"龙悦湾金石院子"最不相似,是不期望得到的结果.

打印结果:

4.最终解决方案

将字符串和目标字符串去空格后转为单字符集,定义一个变量intersection,自定义算法计算让intersection值增加,相似度百分比值=intersection*2/unionLength(两个字符串长度和)*100.

代码如下:

 public static String compareStrings(String str1, String str2) {
        DecimalFormat df = new DecimalFormat("0.00");//格式化小数
        ArrayList pairs1 = wordLetterPairs(str1.toUpperCase());
        ArrayList pairs2 = wordLetterPairs(str2.toUpperCase());
        int intersection = 0;
        int union = pairs1.size() + pairs2.size();
        for (int i=0; i<pairs1.size(); i++) {
            Object pair1=pairs1.get(i);
            for(int j=0; j<pairs2.size(); j++) {
                Object pair2=pairs2.get(j);
                if (pair1.equals(pair2)) {
                    intersection++;
                    pairs2.remove(j);
                    break;
                }
            }
        }
        return df.format((2.0*intersection)/union*100)+"%";
    }
private static String[] letterPairs(String str) {
        int numPairs = str.length()-1;
        String[] pairs = new String[numPairs];
        for (int i=0; i<numPairs; i++) {
            pairs[i] = str.substring(i,i+2);
        }
        return pairs;
    }

    private static ArrayList wordLetterPairs(String str) {
        ArrayList allPairs = new ArrayList();
        String[] words = str.split("\\s");
        for (int w=0; w < words.length; w++) {
            String[] pairsInWord = letterPairs(words[w]);
            for (int p=0; p < pairsInWord.length; p++) {
                allPairs.add(pairsInWord[p]);
            }
        }
        return allPairs;
    }

运行结果:正确