Java 判断两个字符串是否由相同的字符组成的实例

Java 判断两个字符串是否由相同的字符组成的实例

问题：由相同的字符组成是指两个字符串，字母以及各个字母的个数是相同的，只是顺序不同。如：“aaaabbc”与“abcbaaa”是由相同字符组成。

方法一：排序法，也是最容易想到的方法，将两个字符串转换为字节数组，分别排序后，判断是否相同即可。

方法二：集合法（空间换时间），利用Map集合key的唯一性，遍历第一个字符串，将字符作为key，字符出现的次数作为value，若遇到重复字符则将value+1。之后遍历第二个字符串，遇到字符就将对应的value-1,若value值为1时，就将该字符remove掉。最后判断map是否为空，为空则说明两字符串相同。

方法三：数组法（空间换时间）：由于ASCII字符共266个，，申请一个字节数组byte[256]，初始化为0，然后遍历第一个字符串，将对应的ASCII下标+1，然后遍历第二个字符串，将对应标-1。若最后数组中各个元素的值都是0，则说明字符串相等，反之不等。

先给出方法二，方法三源码：

package CharString;

import java.util.HashMap;

import java.util.Map;

public class CompareString {

public static boolean compare(char[] a,char[] b){

int aLen = a.length;

int bLen = b.length;

if(aLen!=bLen){

return false;

}

Map map = new HashMap();

for(int i=0;i

if(map.containsKey(a[i])){

map.put(a[i], map.get(a[i])+1);

}else{

map.put(a[i], 1);

}

}

for(int j=0;j

if(map.containsKey(a[j])&&map.get(a[j])==1){

map.remove(a[j]);

}else{

map.put(a[j], map.get(a[j])-1);

}

}

return map.isEmpty();

}

public static boolean compare2(String a,String b){

byte[] b1 = a.getBytes();

byte[] b2 = b.getBytes();

int[] bCount = new int[256];

for(int i=0;i<256;i++){

bCount[i] = 0;

}

for(int i=0;i

bCount[b1[i]-'0']++;

for(int i=0;i

bCount[b2[i]-'0']--;

for(int i=0;i<256;i++){

if(bCount[i]!=0)

return false;

}

return true;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuffer s11 = new StringBuffer();

StringBuffer s22 = new StringBuffer();

for(int i=0;i<10000;i++){

s11.append("aybcybayaatt");

}

for(int i=0;i<10000;i++){

s22.append("aybcybayaatt");

}

String s1 = s11.toString();

String s2 = s22.toString();

char[] a = s1.toCharArray();

char[] b = s2.toCharArray();

long l3=System.currentTimeMillis();

System.out.println(compare(a,b));

long l4=System.currentTimeMillis();

System.out.println("集合用时："+(l4-l3));

long l1=System.currentTimeMillis();

System.out.println(compare2(s1,s2));

long l2=System.currentTimeMillis();

System.out.println("数组用时："+(l2-l1));

}

}

为了测试，两个方法的运行时间，构造较大的字符串，运行结果：

true

集合用时：54毫秒

true

数组用时：17毫秒

由此可见，数组法的运行效率更高，若在对空间没要求的情况下，推荐使用第三种方法。

if(map.containsKey(a[i])){

map.put(a[i], map.get(a[i])+1);

}else{

map.put(a[i], 1);

}

}

for(int j=0;j

if(map.containsKey(a[j])&&map.get(a[j])==1){

map.remove(a[j]);

}else{

map.put(a[j], map.get(a[j])-1);

}

}

return map.isEmpty();

}

public static boolean compare2(String a,String b){

byte[] b1 = a.getBytes();

byte[] b2 = b.getBytes();

int[] bCount = new int[256];

for(int i=0;i<256;i++){

bCount[i] = 0;

}

for(int i=0;i

bCount[b1[i]-'0']++;

for(int i=0;i

bCount[b2[i]-'0']--;

for(int i=0;i<256;i++){

if(bCount[i]!=0)

return false;

}

return true;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuffer s11 = new StringBuffer();

StringBuffer s22 = new StringBuffer();

for(int i=0;i<10000;i++){

s11.append("aybcybayaatt");

}

for(int i=0;i<10000;i++){

s22.append("aybcybayaatt");

}

String s1 = s11.toString();

String s2 = s22.toString();

char[] a = s1.toCharArray();

char[] b = s2.toCharArray();

long l3=System.currentTimeMillis();

System.out.println(compare(a,b));

long l4=System.currentTimeMillis();

System.out.println("集合用时："+(l4-l3));

long l1=System.currentTimeMillis();

System.out.println(compare2(s1,s2));

long l2=System.currentTimeMillis();

System.out.println("数组用时："+(l2-l1));

}

}

为了测试，两个方法的运行时间，构造较大的字符串，运行结果：

true

集合用时：54毫秒

true

数组用时：17毫秒

由此可见，数组法的运行效率更高，若在对空间没要求的情况下，推荐使用第三种方法。

if(map.containsKey(a[j])&&map.get(a[j])==1){

map.remove(a[j]);

}else{

map.put(a[j], map.get(a[j])-1);

}

}

return map.isEmpty();

}

public static boolean compare2(String a,String b){

byte[] b1 = a.getBytes();

byte[] b2 = b.getBytes();

int[] bCount = new int[256];

for(int i=0;i<256;i++){

bCount[i] = 0;

}

for(int i=0;i

bCount[b1[i]-'0']++;

for(int i=0;i

bCount[b2[i]-'0']--;

for(int i=0;i<256;i++){

if(bCount[i]!=0)

return false;

}

return true;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuffer s11 = new StringBuffer();

StringBuffer s22 = new StringBuffer();

for(int i=0;i<10000;i++){

s11.append("aybcybayaatt");

}

for(int i=0;i<10000;i++){

s22.append("aybcybayaatt");

}

String s1 = s11.toString();

String s2 = s22.toString();

char[] a = s1.toCharArray();

char[] b = s2.toCharArray();

long l3=System.currentTimeMillis();

System.out.println(compare(a,b));

long l4=System.currentTimeMillis();

System.out.println("集合用时："+(l4-l3));

long l1=System.currentTimeMillis();

System.out.println(compare2(s1,s2));

long l2=System.currentTimeMillis();

System.out.println("数组用时："+(l2-l1));

}

}

为了测试，两个方法的运行时间，构造较大的字符串，运行结果：

true

集合用时：54毫秒

true

数组用时：17毫秒

由此可见，数组法的运行效率更高，若在对空间没要求的情况下，推荐使用第三种方法。

bCount[b1[i]-'0']++;

for(int i=0;i

bCount[b2[i]-'0']--;

for(int i=0;i<256;i++){

if(bCount[i]!=0)

return false;

}

return true;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuffer s11 = new StringBuffer();

StringBuffer s22 = new StringBuffer();

for(int i=0;i<10000;i++){

s11.append("aybcybayaatt");

}

for(int i=0;i<10000;i++){

s22.append("aybcybayaatt");

}

String s1 = s11.toString();

String s2 = s22.toString();

char[] a = s1.toCharArray();

char[] b = s2.toCharArray();

long l3=System.currentTimeMillis();

System.out.println(compare(a,b));

long l4=System.currentTimeMillis();

System.out.println("集合用时："+(l4-l3));

long l1=System.currentTimeMillis();

System.out.println(compare2(s1,s2));

long l2=System.currentTimeMillis();

System.out.println("数组用时："+(l2-l1));

}

}

为了测试，两个方法的运行时间，构造较大的字符串，运行结果：

true

集合用时：54毫秒

true

数组用时：17毫秒

由此可见，数组法的运行效率更高，若在对空间没要求的情况下，推荐使用第三种方法。

bCount[b2[i]-'0']--;

for(int i=0;i<256;i++){

if(bCount[i]!=0)

return false;

}

return true;

}

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuffer s11 = new StringBuffer();

StringBuffer s22 = new StringBuffer();

for(int i=0;i<10000;i++){

s11.append("aybcybayaatt");

}

for(int i=0;i<10000;i++){

s22.append("aybcybayaatt");

}

String s1 = s11.toString();

String s2 = s22.toString();

char[] a = s1.toCharArray();

char[] b = s2.toCharArray();

long l3=System.currentTimeMillis();

System.out.println(compare(a,b));

long l4=System.currentTimeMillis();

System.out.println("集合用时："+(l4-l3));

long l1=System.currentTimeMillis();

System.out.println(compare2(s1,s2));

long l2=System.currentTimeMillis();

System.out.println("数组用时："+(l2-l1));

}

}

为了测试，两个方法的运行时间，构造较大的字符串，运行结果：

true

集合用时：54毫秒

true

数组用时：17毫秒

由此可见，数组法的运行效率更高，若在对空间没要求的情况下，推荐使用第三种方法。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。