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

[mysuixiang]

源地址http://iwgod.com/know_showKnowledgeByID=knowledge.kid_113.htm

/**
 * 运行结果 大概 
一次调用 a b b2 c d 顺序
[d, a, c, b]前面是输出 a 方法 耗时188

bacd前面是输出 b 方法 耗时78

bacd前面是输出 b2 方法 耗时219

dacb前面是输出 c 方法 耗时1468

abcd前面是输出 d 方法 耗时47


	
一次调用方法 d c b2 b a 顺序

abcd前面是输出 d 方法 耗时47

dacb前面是输出 c 方法 耗时1875

bacd前面是输出 b2 方法 耗时219

bacd前面是输出 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
好

[mysuixiang]

来人呀

[mysuixiang]

怎么没人呀

[soli11722984]

有人，不过不知道你想问啥而已

[colin_pxx]

白顶一下

[wutian4567268]

帮顶了。。。。。。。。。。

[newplayerone]

看不大懂对话。不过去除重复字符的方法很不错。尤其是最后一个。
a.方法和c.方法用了hashMap和hashSet所以速度上要慢一些。
需要处理对象，速度肯定上不去，Set插入的时候还需要去除重复对象肯定更慢了。
在堆里面进进出出，用块来查找确实不如堆栈的效率高

d.方法眼前一亮。楼主咋想到的？很佩服啊，完全用基本数据类型就实现了

b和b2的方法用String和StringBuffer。但是在b2里面循环里面做类型转化，这个肯定速度也就慢了

是面试题吧？挺不错的顶一把，有说错的地方楼下的修正

[henoy]

.....

[mysuixiang]

不好意思,我想问的是我这么测试运行的时间是否正确.
还有就是 白菜说的话是否是对的.

[mysuixiang]

比如这两个方法 我运行起来
结果 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);
    }

[soli11722984]

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

[mysuixiang]

确实都是同一个实现,我想问问 转化到这两个方法上,来看所用的时间为什么是 c方法用的时间比a方法要长很多呢

[soli11722984]

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段各自的效率已经差异很大了

[公众号【架构师也是人】]

没用到，但是关注一下

[piaoliumooo]

这个我也不明白