求助:java去掉字符串中重复值,方法效率比较

Question

源地址http://iwgod.com/know_showKnowledgeByID=knowledge.kid_113.htm
/**
 * 运行结果 大概 
一次调用 a b b2 c d 顺序
[d, a, c, b]前面是输出 a 方法 耗时188bacd前面是输出 b 方法 耗时78bacd前面是输出 b2 方法 耗时219dacb前面是输出 c 方法 耗时1468abcd前面是输出 d 方法 耗时47

一次调用方法 d c b2 b a 顺序abcd前面是输出 d 方法 耗时47dacb前面是输出 c 方法 耗时1875bacd前面是输出 b2 方法 耗时219bacd前面是输出 b 方法 耗时62[d, a, c, b]前面是输出 a 方法 耗时156不知道这么测试对不对.新手疑问 */
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void a(String str){
HashMap map = new HashMap();
for(int i=0;i<str.length();i++)
{
String strchar = str.substring(i, i+1);
map.put(strchar, strchar);
}
System.out.print(map.keySet());
}

public static void b(String str){
char[] cs = str.toCharArray();
String _s = String.valueOf(cs[0]);
for (int i = 0; i < cs.length; i++) {
if(_s.indexOf((int)cs[i]) == -1){
_s += String.valueOf(cs[i]);
}
}
System.out.print(_s);
}

public static void b2(String strs) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < strs.length(); i++) {
if (sb.indexOf(String.valueOf(strs.charAt(i))) == -1) {
sb.append(strs.charAt(i));
}
}
System.out.print(sb.toString());
}

public static void c(String funs){  
String[] fun=funs.split("");
Set set = new HashSet();
for(String f:fun){
set.add(f);
}
String temp="";
Iterator i=set.iterator();
while(i.hasNext()){
temp += i.next();
}
System.out.print(temp);
}

public static void d(String strs){  
char[] cs = strs.toCharArray();
char[] _cs = new char[127];
for (int i = 0,j = _cs.length; i < j; i++) {
_cs[cs[i]] = cs[i];
}
String str = "";
for (int i = 0; i < _cs.length; i++) {  
if((int)_cs[i] != 0){
str += _cs[i];
}
}
System.out.print(str);
}

public static void main(String[] args) {  
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 45000; i++) {    
sb.append("bbbbbbbbbbbbbbbbaaaaaaaaccddaaaaaaa");
} long a = new Date().getTime();
Test.a(sb.toString());
long b = new Date().getTime();
System.out.println("前面是输出 a 方法 耗时"+(b-a)+"\n");

a = new Date().getTime();
Test.b(sb.toString());
b = new Date().getTime();
System.out.println("前面是输出 b 方法 耗时"+(b-a)+"\n");

a = new Date().getTime();
Test.b2(sb.toString());
b = new Date().getTime();
System.out.println("前面是输出 b2 方法 耗时"+(b-a)+"\n");

a = new Date().getTime();
Test.c(sb.toString());
b = new Date().getTime();
System.out.println("前面是输出 c 方法 耗时"+(b-a)+"\n");

a = new Date().getTime();
Test.d(sb.toString());
b = new Date().getTime();
System.out.println("前面是输出 d 方法 耗时"+(b-a)+"\n");
 
}
} 犹豫下面的对话让我产生疑惑,谁能说明说明,小弟学习学习日期:2010-5-13 杭州-JAVA(464649257) 00:43:56
我的方法速度是多少 杭州-JAVA(464649257) 00:43:57
? 随想(451624324) 00:44:24
b 方法 耗时78 随想(451624324) 00:44:29
你的是b的样子 杭州-JAVA(464649257) 00:44:37
我的和B方法不一样 杭州-JAVA(464649257) 00:44:39
你看好了 随想(451624324) 00:45:02
啊不对 随想(451624324) 00:45:10
你用的stringbuff 随想(451624324) 00:45:15
这个会很慢 杭州-JAVA(464649257) 00:45:34
为什么这么说 杭州-JAVA(464649257) 00:46:00
...................不和你说了,你太牛了................. 随想(451624324) 00:46:02
不知道一样不我干才也这么写了.我运行下你的看看 随想(451624324) 00:47:30
[d, a, c, b]
a 方法 耗时204
bacd
b 方法 耗时78
bacdb2 方法 耗时218
dacb
c 方法 耗时1485
abcd
d 方法 耗时47
 
随想(451624324) 00:47:43
没错 你的方法 耗时218 杭州-JAVA(464649257) 00:48:08
那是最慢的了 随想(451624324) 00:48:29
用 set的最慢 杭州-JAVA(464649257) 00:48:48
好了,别扯了 随想(451624324) 00:48:53
哦 杭州-JAVA(464649257) 00:48:57
SET 和MAP 代码是一样的 杭州-JAVA(464649257) 00:49:07
源代码看过没有 随想(451624324) 00:49:27
没看过 杭州-JAVA(464649257) 00:49:50
好了,没有看过就别说了,让人感到好笑 杭州-JAVA(464649257) 00:50:06
你把这四个方法,换个顺序,运行的时间又变了 随想(451624324) 00:50:12
呵呵, 杭州-JAVA(464649257) 00:50:16
你看一下是不是 随想(451624324) 00:50:22
我试试 随想(451624324) 00:51:43
好像没变 随想(451624324) 00:51:52
abcd
d 方法 耗时31
dacb
c 方法 耗时1828
bacdb2 方法 耗时203
bacd
b 方法 耗时63
[d, a, c, b]
a 方法 耗时156
 
杭州-JAVA(464649257) 00:51:52
是吗 杭州-JAVA(464649257) 00:51:55
不可能 随想(451624324) 00:52:03
我也不知道. 杭州-JAVA(464649257) 00:52:23
你的测试数据多不多 随想(451624324) 00:53:12
bbbbbbbbbbbbbbbbaaaaaaaaccddaaaaaaa 循环45000次累加 随想(451624324) 00:53:32
算不算多 杭州-JAVA(464649257) 00:53:33
呵呵 杭州-JAVA(464649257) 00:53:41
你的方法有问题 随想(451624324) 00:53:42
再多set就内存溢出了 随想(451624324) 00:53:52
你可以告诉我正确的方法吗 杭州-JAVA(464649257) 00:54:04
SET的特点是什以 杭州-JAVA(464649257) 00:54:06
么 随想(451624324) 00:54:08
我也不太懂就会那时间- 随想(451624324) 00:54:26
好像是不会出现重复的值 杭州-JAVA(464649257) 00:55:33
好了,没有时间和你扯了, MAP相对最快 杭州-JAVA(464649257) 00:55:43
但是重构对象是最多 杭州-JAVA(464649257) 00:55:53
数据最一大就有问题 杭州-JAVA(464649257) 00:56:08
你没有出问题是因为你的你测试数据有问题 杭州-JAVA(464649257) 00:56:33
MAP和SET 的源码有时间看一下,别没有事讲笑话 杭州-JAVA(464649257) 00:56:49
HASHSET取的是HASHMAP的KEY 杭州-JAVA(464649257) 00:56:52
是一个东西 杭州-JAVA(464649257) 00:57:00
你在这瞎扯 随想(451624324) 00:57:04
哦 随想(451624324) 00:57:08
知道了 杭州-JAVA(464649257) 00:57:21
现在就看源代码也不迟 杭州-JAVA(464649257) 00:57:26
开源的嘛 随想(451624324) 00:57:40
哦好 小白菜 01:06:56
看到了吧小白菜 01:07:09
HASHSET 和HASHMAP随想 01:07:56
还没呢小白菜 01:08:07
晕小白菜 01:08:22
直接看HASHSET就行了随想 01:08:39
我不太清楚我写的这几个方法为什么不对随想 01:09:02
http://iwgod.com/know_showKnowledgeByID=knowledge.kid_113.htm
这个是我的链接你运行下看看好吗小白菜 01:09:10
 
小白菜 01:09:19
这是HASHSET源代码小白菜 01:09:21
看到没有随想 01:09:32
看到了小白菜 01:09:38
你讲的话,差点把我牙笑掉小白菜 01:09:54
没有时间和你扯小白菜 01:09:59
我先睡了,随想 01:10:04
哦睡吧小白菜 01:10:08
JAVA测试不是像你这样测的小白菜 01:10:19
后面的方法,垃圾在回收小白菜 01:10:53
你不懂程序,不懂不要紧,你可以学C++以及STL小白菜 01:11:16
数据结构和算法懂了之后再回过来看一下JAVA里的源码小白菜 01:11:27
要不然直接看源码要有不理解的地方小白菜 01:11:38
为什么看到时间少,别人说是一样的东西随想 01:11:47
恩小白菜 01:11:51
你是想不通为什么随想 01:11:57
恩小白菜 01:12:09
看到源码一样,又怀疑自己错了随想 01:12:15
恩小白菜 01:12:39
有空多学学基础,别研究没用的随想 01:12:49
好

Answer 1

看不大懂对话。不过去除重复字符的方法很不错。尤其是最后一个。
a.方法和c.方法用了hashMap和hashSet所以速度上要慢一些。
需要处理对象，速度肯定上不去，Set插入的时候还需要去除重复对象肯定更慢了。
在堆里面进进出出，用块来查找确实不如堆栈的效率高d.方法眼前一亮。楼主咋想到的？很佩服啊，完全用基本数据类型就实现了b和b2的方法用String和StringBuffer。但是在b2里面循环里面做类型转化，这个肯定速度也就慢了是面试题吧？挺不错的顶一把，有说错的地方楼下的修正

Answer 2

比如这两个方法 我运行起来 
结果 a 140+ 明显比 c 1400+ 快 字符串是 bbbbbbbbbbbbbbbbaaaaaaaaccddaaaaaaa 这个循环累加45000次 去重复
可是小白菜说 a和c是一样的,不太懂public static void a(String str){
        HashMap map = new HashMap();
        for(int i=0;i<str.length();i++)
        {
            String strchar = str.substring(i, i+1);
            map.put(strchar, strchar);        
        }
        System.out.print(map.keySet());        
    }    public static void c(String funs){         
        String[] fun=funs.split("");
        Set set = new HashSet();
        for(String f:fun){
            set.add(f);
        }
        String temp="";
        Iterator i=set.iterator();
        while(i.hasNext()){
            temp += i.next();
        }
        System.out.print(temp);
    }

Answer 3

HashSet的实现其实就是HashMap的键的实现，源码确实就是这样，只是HashSet的对应HashMap里的键值对，值全为null而已，所以HashSet说保存的结果集不重复和HashMap的键只有唯一一个，都是同一个实现

Answer 4

String strchar = str.substring(i, i+1);
map.put(strchar, strchar); 
和
set.add(f);
还有
System.out.print(map.keySet()); 
和
while(i.hasNext()){
    temp += i.next();
}
System.out.print(temp);就这2段各自的效率已经差异很大了