请高手指点，简单的几个数组操作方法不知道是否可以有更好的改进方法或者更简单的方法？

转载 于 2010-11-19 21:07:00 发布 · 601 阅读 · 0
文章标签：

#string #assembly #null #.net #linq #lambda

本文探讨了数组操作中的几个常见方法，包括判断数组中是否存在特定元素、合并多个数组并去除重复项以及从数组中移除指定元素。通过对现有代码的分析和讨论，提出了多种改进方案和技术建议。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

总觉得以下方法写得不是最优化，希望得到高手指点，如何改进代码量最少，运行速度最优？
 1          /// <summary>
 2        /// 判断是否包含的方法
 3        /// </summary>
 4        /// <param name="ids">数组</param>
 5        /// <param name="targetString">目标值</param>
 6        /// <returns>包含</returns>
 7          public   static   bool  Exists(String[] ids, String targetString)
  8          {
 9            bool returnValue = false;
10            for (int i = 0; i < ids.Length; i++)
11            {
12                if (ids[i].Equals(targetString))
13                {
14                    returnValue = true;
15                    break;
16                }
17            }
18            return returnValue;
19        }
20         
 21          /// <summary>
22        /// 合并数组
23        /// </summary>
24        /// <param name="ids">数组</param>
25        /// <returns>数组</returns>
26          public   static  String[] Concat( params  String[][] ids)
 27          {
28            // 进行合并
29            Hashtable hashValues = new Hashtable();
30            if (ids != null)
31            {
32                for (int i = 0; i < ids.Length; i++)
33                {
34                    if (ids[i] != null)
35                    {
36                        for (int j = 0; j < ids[i].Length; j++)
37                        {
38                            if (!hashValues.ContainsKey(ids[i][j]))
39                            {
40                                hashValues.Add(ids[i][j], ids[i][j]);
41                            }
42                        }
43                    }
44                }
45            }
46            // 返回合并结果
47            String[] returnValues = new String[hashValues.Count];
48            IDictionaryEnumerator enumerator = hashValues.GetEnumerator();
49            int key = 0;
50            while (enumerator.MoveNext())
51            {
52                returnValues[key] = (String)(enumerator.Key.ToString());
53                key++;
54            }
55            return returnValues;
56        }
57
58          /// <summary>
59        /// 从目标数组中去除某个值
60        /// </summary>
61        /// <param name="ids">数组</param>
62        /// <param name="id">目标值</param>
63        /// <returns>数组</returns>
64          public   static  String[] Remove(String[] ids, String id)
 65          {
66            // 进行合并
67            Hashtable hashValues = new Hashtable();
68            if (ids != null)
69            {
70                for (int i = 0; i < ids.Length; i++)
71                {
72                    if (ids[i] != null && (!ids[i].Equals(id)))
73                    {
74                        if (!hashValues.ContainsKey(ids[i]))
75                        {
76                            hashValues.Add(ids[i], ids[i]);
77                        }
78                    }
79                }
80            }
81            // 返回合并结果
82            String[] returnValues = new String[hashValues.Count];
83            IDictionaryEnumerator enumerator = hashValues.GetEnumerator();
84            int key = 0;
85            while (enumerator.MoveNext())
86            {
87                returnValues[key] = (String)(enumerator.Key.ToString());
88                key++;
89            }
90            return returnValues;
91        }
日常开发中经常会遇到对数组的处理，例如发送短信提醒时，总没必要给自己也发一条，那不是浪费5分钱，
还浪费感情，还需要删除掉手机里的没用短信，这就是所谓的细节吧，那就应该是从发送目标数组里把当前
操作员去掉比较友善一些。  
 1          /// <summary>
 2        /// 邮件提醒，需要发给别人邮件手机短信提醒的功能接口
 3        /// </summary>
 4        /// <param name="dbHelper">数据库连接</param>
 5        /// <param name="userInfo">当前用户</param>
 6        /// <param name="userIDs">用户代码组</param>
 7        /// <param name="messageContent">短信内容</param>
 8        /// <returns>发送短信条数</returns>
 9          public   static   int  SendMessage(IDbHelper dbHelper, BaseUserInfo userInfo, String[] userIDs, String messageContent)
 10          {
11            // 没必要自己给自己发邮件，把自己从发邮件列表里去掉
12            userIDs = BaseBusinessLogic.Remove(userIDs, userInfo.ID);


例如，我要点选好几个部门，要知道这些部门里都有哪些用户？并且合并数组，得到最终的目标数组  
 1           public  String[] GetUserIDs(String organizeID)
  2          {
  3               //  要注意不能重复发信息，只能发一次。
 4              String[] companyUsers  =   null ;  //  按公司查找用户
 5              String[] departmentUsers  =   null ;  //  按部门查找用户
 6              String[] workgroupUsers  =   null ;  //  按工作组查找用户
 7               if  ( ! String.IsNullOrEmpty(organizeID))
  8              {
  9                   //  这里获得的是用户主键，不是员工代码
10                  BaseStaffDao staffDao  =   new  BaseStaffDao( this .DbHelper);
 11                  companyUsers  =  staffDao.GetIDs(BaseStaffTable.FieldCompanyID, organizeID, BaseStaffTable.FieldUserID);
 12                  departmentUsers  =  staffDao.GetIDs(BaseStaffTable.FieldDepartmentID, organizeID, BaseStaffTable.FieldUserID);
 13                  workgroupUsers  =  staffDao.GetIDs(BaseStaffTable.FieldWorkgroupID, organizeID, BaseStaffTable.FieldUserID);
 14              }
 15              String[] userIDs  =  BaseBusinessLogic.Contact(companyUsers, departmentUsers, workgroupUsers);
 16               return  userIDs;
 17          }
 18 
19           public  String[] GetUserIDs(String[] organizeIDs, String[] roleIDs)
 20          {
 21               //  要注意不能重复发信息，只能发一次。
22              String[] companyUsers  =   null ;  //  按公司查找用户
23              String[] departmentUsers  =   null ;  //  按部门查找用户
24              String[] workgroupUsers  =   null ;  //  按工作组查找用户
25               if  (organizeIDs  !=   null )
 26              {
 27                   //  这里获得的是用户主键，不是员工代码
28                  BaseStaffDao staffDao  =   new  BaseStaffDao( this .DbHelper);
 29                  companyUsers  =  staffDao.GetIDs(BaseStaffTable.FieldCompanyID, organizeIDs, BaseStaffTable.FieldUserID);
 30                  departmentUsers  =  staffDao.GetIDs(BaseStaffTable.FieldDepartmentID, organizeIDs, BaseStaffTable.FieldUserID);
 31                  workgroupUsers  =  staffDao.GetIDs(BaseStaffTable.FieldWorkgroupID, organizeIDs, BaseStaffTable.FieldUserID);
 32              }
 33              String[] roleUsers  =   null ;
 34               if  (roleIDs  !=   null )
 35              {
 36                  BaseUserRoleDao userRoleDao  =   new  BaseUserRoleDao( this .DbHelper);
 37                  roleUsers  =  userRoleDao.GetIDs(BaseUserRoleTable.FieldRoleID, roleIDs, BaseUserRoleTable.FieldUserID);
 38              }
 39              String[] userIDs  =  BaseBusinessLogic.Contact(companyUsers, departmentUsers, workgroupUsers, roleUsers);
 40               return  userIDs;
 41          }
 42 
43           public  String[] GetUserIDs(String[] userIDs, String[] organizeIDs, String[] roleIDs)
 44          {
 45               return  BaseBusinessLogic.Contact(userIDs,  this .GetUserIDs(organizeIDs, roleIDs));
 46          }

每天提高一点点，每天变得谦虚一点点。


导读：
疯狂.NET架构通用权限后台管理工具演示版2.0下载
疯狂.NET 通用权限设计 C/S后台管理，B/S前台调用源码样例程序源码下载之 --- 操作权限
疯狂.NET 通用权限设计 C/S后台管理，B/S前台调用源码样例程序源码下载之 --- 角色权限
疯狂.NET 通用权限设计 C/S后台管理，B/S前台调用源码样例程序源码下载之 --- 数据集权限

淘宝店地址：
http://shop59297253.taobao.com/



将权限管理、工作流管理做到我能力的极致，一个人只能做好那么很少的几件事情。

posted on 2009-09-18 13:03 不仅仅是通用权限设计 阅读(2013) 评论(76) 编辑 收藏

#1楼 　 回复　 引用　 查看　    看了一眼，都是循环，数据量一大，性能就会出现问题。

2009-09-18 13:06 | hhshuai       

#2楼[楼主] 　回复　引用　查看　  

@hhshuai

那有什么好办法能提高速度不？
2009-09-18 13:13 | 吉日嘎拉>不仅权限设计       

#3楼 　回复　引用　  

五百块...OK?
2009-09-18 13:19 | ...............[未注册用户]

#4楼 　回复　引用　  

五百块...OK？
2009-09-18 13:20 | 要收费的[未注册用户]

#5楼 　回复　引用　  

引用要收费的：五百块...OK？

OK..OK..
2009-09-18 13:22 | OKOK...........[未注册用户]

#6楼 　回复　引用　  

引用OKOK...........：
引用要收费的：五百块...OK？

OK..OK..

连吉日都不知道的东西才值五百块。。。。。
砖家都不愿意动手了。
2009-09-18 13:24 | 吉日不厚道[未注册用户]

#7楼 　回复　引用　查看　  

可以参考下.Net Framework中的源代码
2009-09-18 13:27 | James.Ying       

#8楼 　回复　引用　查看　  

难道最大性能瓶颈不是在数据库访问吗？如：companyUsers = staffDao.GetIDs(BaseStaffTable.FieldCompanyID.......

1.如果可以缓存所有用户id，这就很好解决了..
2.换个思路： 送一个对象给发信息的接口，而非string[]：
class SendList
{
public List<string[]> users{get;set;}
public string excludeUserId{get;set;}
}

那么 Contact 和 Minus 就都不用了...
2009-09-18 13:28 | CoolCode       

#9楼 　回复　引用　  

从目标数组中去除某个值

在下认为。在一次遍历的时候你可以用另一个数组去存值

1 arr=[1,2,3,1,4,5]
2 hash={}
3 i = 0
4 b=[]
5 while(i<arr.size)
6 if(!hash.keys.include?(arr[i]))
7 hash[arr[i]] =arr[i]
8 b << arr[i]
9 end
10 i+=1
11 --
12 end
2009-09-18 13:30 | 我朋友老说我蠢[未注册用户]

#10楼 　回复　引用　查看　  

建议把Hashtable 换成泛型的 Dictionary<Tkey,Tvalue>。
2009-09-18 13:35 | 张少峰       

#11楼 　回复　引用　  

分别用Array.Exists
Array.Copy
Array.FindAll替代可以简化操作
2009-09-18 13:36 | 鸟窝[未注册用户]

#12楼 　回复　引用　查看　  

为什么要用数组？？？
2009-09-18 13:42 | jivi       

#13楼 　回复　引用　查看　  

去除的方法名是不是叫Remove更合适呀？
2009-09-18 13:44 | 阿水       

#14楼 　回复　引用　查看　  

我现在用List<T>的几率比数组要大~
2009-09-18 13:45 | 张少峰       

#15楼 　回复　引用　查看　  

哦，楼主开始贴代码了，这可是突破啊！
2009-09-18 14:03 | 淘者天下2       

#16楼 　回复　引用　查看　  

引用鸟窝：
分别用Array.Exists
Array.Copy
Array.FindAll替代可以简化操作

是简化了，但是用到了委托，性能估计还不如吉日写的方法。
2009-09-18 14:04 | 张少峰       

#17楼 　回复　引用　查看　  

public static String[] Contact(params String[][] ids)

contact???
应该是concat吧。。。
2009-09-18 14:06 | xiao_p       

#18楼 　回复　引用　  

集合都用泛形...
2009-09-18 14:14 | 1980[未注册用户]

#19楼 　回复　引用　查看　  

楼主,我给你改一下第一个方法.

public static bool Exists<T>(this Array obj, T value) {
foreach (T item in obj) {
if (item.Equals(value)) {
return true;
}
}
return false;
}
2009-09-18 14:15 | 狼Robot       

#20楼 　回复　引用　  

lambda:

public static bool Exists(String[] ids, String targetString)
{
if (ids.Contains(targetString))
return true;
return false;
}
2009-09-18 14:16 | Ray Gu777[未注册用户]

#21楼 　回复　引用　查看　  

引用Ray Gu777：
lambda:

public static bool Exists(String[] ids, String targetString)
{
if (ids.Contains(targetString))
return true;
return false;
}


如果数组真有Contains方法的话，完全可以这么写：
public static bool Exists(String[] ids, String targetString)
{
return ids.Contains(targetString);
}
2009-09-18 14:22 | 张少峰       

#22楼 　回复　引用　  

public static String[] Minus(String[] ids, String id)
{
if (ids.Contains(id))
{
return ids.Where(x => x != id).ToArray();
}
return ids;
}
2009-09-18 14:29 | Ray Gu777[未注册用户]

#23楼 　回复　引用　  

我也看不大懂！~
2009-09-18 14:39 | 赤龙虾[未注册用户]

#24楼 　回复　引用　  

引用张少峰：
引用Ray Gu777：
lambda:

public static bool Exists(String[] ids, String targetString)
{
if (ids.Contains(targetString))
return true;
return false;
}


如果数组真有Contains方法的话，完全可以这么写：
public static bool Exists(String[] ids, String targetString)
{
return ids.Contains(targetString);
}


lambda 就包括 Contains
2009-09-18 14:42 | Ray Gu777[未注册用户]

#25楼 　回复　引用　  

代码的简化并不代表性能的提升~
2009-09-18 15:20 | -_-#[未注册用户]

#26楼[楼主] 　回复　引用　查看　  

@阿水
的确 Remove 更合适一些，谢谢提醒。
2009-09-18 15:26 | 吉日嘎拉>不仅权限设计       

#27楼[楼主] 　回复　引用　查看　  

@Ray Gu777
ids.Contains(targetString)) 没有这个方法？ 是不是要引用什么才可以？
2009-09-18 15:28 | 吉日嘎拉>不仅权限设计       

#28楼 　回复　引用　查看　  

使用Dictionary<Tkey, Tvalue>，其中TValue为null，来代替你所有的string array。
2009-09-18 15:31 | Jake.NET       

#29楼 　回复　引用　查看　  

基本上不能在简了
2009-09-18 15:33 | lola       

#30楼[楼主] 　回复　引用　查看　  

@xiao_p

谢谢您的回复，的确应该是 Concat 比较贴切一些。
2009-09-18 15:34 | 吉日嘎拉>不仅权限设计       

#31楼 　回复　引用　查看　  

查找是否包含，从头到尾遍历不好，用二分查找就比这块
2009-09-18 15:35 | 农民学编程       

#32楼 　回复　引用　  

@吉日嘎拉&gt;不仅权限设计

有的，但是我说的前提是基于linq to object的，你只有在framework3.0以上的环境中才能用
2009-09-18 15:35 | RayGu777[未注册用户]

#33楼 　回复　引用　查看　  


#34楼 回复 引用 查看
查找是否包含，从头到尾遍历不好，用二分查找就比这块
2009-09-18 15:35 | 农民学编程


太扯了吧,又不是有序的数组,你二分个什么劲呀
2009-09-18 15:48 | Yunanw       

#34楼 　回复　引用　查看　  

吉老师偶然的谦虚，让我一下子适应不过来。
2009-09-18 16:11 | 在别处       

#35楼 　回复　引用　查看　  

第一个方法中，将 ids[i].Equals(targetString) 修改为
object.ReferenceEquals(ids[i], targetString) 可提高效率。
string.Equals(string)方法逐个char进行比较，效率相对较低。
2009-09-18 17:01 | 鹤冲天       

#36楼 　回复　引用　查看　  

引用张少峰：如果数组真有Contains方法的话...

数组有Contains方法，在.NET Framework 2.0 版中，Array 类实现ICollection<T>接口，但必须如下书写代码：
view source
print ?
1string[] ss = new string[] { "1", "2" };
2bool b = (ss as ICollection<string>).Contains("1");

MSDN中说明如下：
在.NET Framework 2.0 版中，Array 类实现 System.Collections.Generic.IList<T>、System.Collections.Generic.ICollection<T> 和 System.Collections.Generic.IEnumerable<T> 泛型接口。由于实现是在运行时提供给数组的，因而对于文档生成工具不可见。因此，泛型接口不会出现在 Array 类的声明语法中，也不会有关于只能通过将数组强制转换为泛型接口类型（显式接口实现）才可访问的接口成员的参考主题。将某一数组强制转换为这三种接口之一时需要注意的关键一点是，添加、插入或移除元素的成员会引发 NotSupportedException。
2009-09-18 17:15 | 鹤冲天       

#37楼 　回复　引用　查看　  

别随便帖代码，把水平都暴露出来了不好_
2009-09-18 17:19 | 拼命占便宜       

#38楼 　回复　引用　查看　  

引用鹤冲天：
第一个方法中，将 ids[i].Equals(targetString) 修改为
object.ReferenceEquals(ids[i], targetString) 可提高效率。
string.Equals(string)方法逐个char进行比较，效率相对较低。


假如他的这个targetString是用string.Concat拼出来的,用对象比较的方式不太妥吧,我觉得String重写==是有意义的.
2009-09-18 17:24 | Funeral       

#39楼 　回复　引用　查看　  

看上去LZ的代码是基于.Net Framework2.0的

那第一个代码:
public static bool Exists(String[] ids, String targetString)
{
bool returnValue = false;
for (int i = 0; i < ids.Length; i++)
{
if (ids[i].Equals(targetString))
{
returnValue = true;
break;
}
}
return returnValue;
}
可以写成
public static bool Exists(string[] ids,string targetString)
{
return Array.Exists<string>(ids,
new Predicate<string>(
delegate(string str){
return str == targetString;}));
}

这个性能要比原代码好些
2009-09-18 17:33 | Funeral       

#40楼 　回复　引用　查看　  

建议楼主从泛型角度考虑，不只是对String类型，比如：
view source
print ?
01/// <summary>
02/// 判断对象是否属于某个集合
03/// </summary>
04/// <param name="Assembly">集合</param>
05/// <param name="obj">对象</param>
06public static bool IsMember(IEnumerable Assembly, object obj)
07{
08    if (Assembly == null) return false;
09    IEnumerator Enum = Assembly.GetEnumerator();
10    while (Enum.MoveNext())
11    {
12        if (Enum.Current.Equals(obj)) return true;
13    }
14    return false;
15}
2009-09-18 17:42 | 小城故事       

#41楼 　回复　引用　查看　  

http://www.im286.cn/html/zixun/2009/0829/2327.html
老吉的文章被别的网站转载了。
2009-09-18 17:52 | Breeze Woo       

#42楼 　回复　引用　查看　  

IEnumerable<T> 有扩展方法的，比如 Contains
这些基本上现在不要自己写了。
另外集合的预算也有了，Concat 也应该不要自己写。
2009-09-18 18:32 | 木野狐(Neil Chen)       

#43楼 　回复　引用　查看　  

其实楼主这几个方法性能都不太差，而且，这些case，一般也不会是程序的性能瓶颈。

不过，不得不说，这几段代码的健壮性、可维护性，易读性都很差，不是一般的差，在我们这里一定通不过code review。我实在看不下去，义务改两个，如果改得不好，欢迎拍砖。



而且，你只能用.net 1.1? 如果可以用2.0的泛型甚至3.0以上的扩展方法，linq等等的话，代码能改得优美的多。
2009-09-18 18:32 | Teddy's Knowledge Base       

#44楼[楼主] 　回复　引用　查看　  

@Teddy's Knowledge Base

错了哪里错了？就说出来，否则跟没说有啥区别？
我是本着交流学习的心态，把代码帖出来，别人说有错，我马上就修正了，
你说哪里不对，应该怎么修改？为什么不对？我还当你是恩师了，

光说风凉话，我还想说博客园太简陋了，我2天就能弄出来，光说不练了。
到底哪里丑陋了，就说出来就是水平。
2009-09-18 18:45 | 吉日嘎拉>不仅权限设计       

#45楼 　回复　引用　  

引用小城故事：
建议楼主从泛型角度考虑，不只是对String类型，比如：
...

2009-09-18 18:52 | 请问用不用泛型能有多大差别？[未注册用户]

#46楼 　回复　引用　查看　  

@吉日嘎拉>不仅权限设计:
请你不要激动，睁大眼睛看清楚，我的留言里包含了完整的代码加注释。点击“expand source”就能站看代码。
2009-09-18 18:53 | Teddy's Knowledge Base       

#47楼 　回复　引用　查看　  

对于楼主的代码：
1.判断是否包含的方法
a)Array.Exists<int>(ids, targetString=> targetString== "要匹配的字符串");
b)IList idsNew = ids;
idsNew.Contains("要匹配的字符串");
注：其中ids为源数组
2.合并数组
string[] names = { "pxl", "ljc" };
string[] names2 = { "mmc", "fuck" };
//合并数组
int sourceLength = names.Length;
Array.Resize<string>(ref names, sourceLength + names2.Length);
names2.CopyTo(names, sourceLength);
3.从目标数组中去除某个值
int index = 1;//去除位置
string[] names = { "pxl", "ljc", "mmc", "fuck", "all" };
//nameTmp为去除后的新数组
Array nameTmp = new string[names.Length - 1];
Array.Copy(names, 0, nameTmp, 0, index - 0);
Array.Copy(names, index + 1, nameTmp, index, names.Length - index - 1);
2009-09-18 18:53 | pangxiaoliang[北京]流浪者       

#48楼 　回复　引用　查看　  

下面是第二、三个方法，个人喜欢返回List，当然返回类型也可以用泛型的。不敢说效率最高，应该是最精简易懂的了。
view source
print ?
01/// <summary>
02/// 将多个集合连接并去掉重复值
03/// </summary>
04/// <param name="Assemblies">要连接的集合</param>
05public static List<T> Concat<T>(params IEnumerable<T>[] Assemblies)
06{
07    List<T> lstT = new List<T>();
08    foreach (IEnumerable<T> Asml in Assemblies)
09    {
10        IEnumerator<T> Enum = Asml.GetEnumerator();
11        while (Enum.MoveNext())
12        {
13            T current = Enum.Current;
14            if (lstT.IndexOf(current) >= 0) continue;
15            lstT.Add(current);
16        }
17    }
18    return lstT;
19}
20/// <summary>
21/// 去除重复值
22/// </summary>
23/// <param name="Assembly">要操作的集合</param>
24/// <param name="item">重复值</param>
25public static List<T> Remove<T>(IEnumerable<T> Assembly,T item)
26{
27    List<T> lstT = new List<T>(Assembly);
28    while (lstT.Remove(item)) { }
29    lstT.Add(item);
30    return lstT;
31}
2009-09-18 18:53 | 小城故事       

#49楼 　回复　引用　查看　  

引用木野狐(Neil Chen)：
IEnumerable<T> 有扩展方法的，比如 Contains
这些基本上现在不要自己写了。
另外集合的预算也有了，Concat 也应该不要自己写。

是啊，3.5用起来比2.0方便太多了。
2009-09-18 18:56 | 小城故事       

#50楼 　回复　引用　  

引用Teddy's Knowledge Base：
@吉日嘎拉>不仅权限设计:
请你不要激动，睁大眼睛看清楚，我的留言里包含了完整的代码加注释。点击“expand source”就能站看代码。

2009-09-18 19:01 | 楼主这两天有点累[未注册用户]

#51楼 　回复　引用　  

public static bool Contains(String[] ids, String targetString) //Contains is a better name than Exists for the requirement
{
//always check precondition first
if (ids == null)
{
throw new ArgumentNullException("ids");
}

for (int i = 0; i < ids.Length; ++i)
{
if (ids[i] == targetString) //ids[i].Equals(targetString) throws exception if ids[i] == null
{
return true;
}
}

return false;
}

public static String[] Union(params String[][] ids) //Concat is not the correct word for the requirement
{
//always check precondition first
if (ids == null || ids.Length == 0)
{
return new String[0];
}

//if you could only use .NET 1.1, why not use ArrayList instead of Hashtable if
//you only want the "Contains" function
ArrayList unionedIds = new ArrayList();

for (int i = 0; i < ids.Length; ++i)
{
if (ids[i] != null)
{
for (int j = 0; j < ids[i].Length; ++j)
{
if (!unionedIds.Contains(ids[i][j]))
{
unionedIds.Add(ids[i][j]);
}
}
}
}

//convert ArrayList of string to string[]
String[] returnValues = new String[unionedIds.Count];
for (int i = 0; i < unionedIds.Count; ++i)
{
returnValues[i] = (string)unionedIds[i]; //directcase is faster and safe enough since you could ensure the item is string
}

return returnValues;
}
2009-09-18 19:03 | 谢了[未注册用户]

#52楼 　回复　引用　查看　  

多谢“谢了”帮我把代码给楼主贴出来～～
2009-09-18 19:11 | Teddy's Knowledge Base       

#53楼 　回复　引用　查看　  

哇，Teddy大哥都来贴代码了，他的编码方式应该学习
呵呵
2009-09-18 22:03 | 雄健       

#54楼[楼主] 　回复　引用　查看　  

@Teddy's Knowledge Base

其实我也很感激的，这么多热心人来能帮我看看，
我也虚心向大家学习，每天提高一点点。
2009-09-18 22:11 | 吉日嘎拉>不仅权限设计       

#55楼 　回复　引用　查看　  

Teddy的代码好
2009-09-18 22:17 | Nick Wang (懒人王)       

#56楼 　回复　引用　  

我也从来不检查参数的，自我检讨下。。
2009-09-18 23:10 | 烙馅饼喽_2[未注册用户]

#57楼 　回复　引用　查看　  

这里优化没什么意义吧，到天边几万个数据，操作又不频繁，biu的一下子就结束了
2009-09-19 00:37 | xiaotie       

#58楼 　回复　引用　  

引用吉日嘎拉>不仅权限设计：
@Teddy's Knowledge Base

其实我也很感激的，这么多热心人来能帮我看看，
我也虚心向大家学习，每天提高一点点。

谦虚不是装出来的。
2009-09-19 08:04 | 谦虚是属性，不是方法[未注册用户]

#59楼 　回复　引用　查看　  

引用xiaotie：这里优化没什么意义吧，到天边几万个数据，操作又不频繁，biu的一下子就结束了

大家没事优化着玩玩嘛。老赵说了，西方人就是因为在无聊的事上较真，才有现在的理论水平。咱们也学学~
2009-09-19 08:14 | 张少峰       

#60楼 　回复　引用　查看　  

@Ray Gu777
谢谢指点，不过3.5还真没接触过，孤陋寡闻了。
@鹤冲天
这下我知道了，2.0我也远未玩熟，仍需努力。谢谢你的指点。
2009-09-19 08:19 | 张少峰       

#61楼 　回复　引用　查看　  

@Funeral
引用Funeral：
引用鹤冲天：
第一个方法中，将 ids[i].Equals(targetString) 修改为
object.ReferenceEquals(ids[i], targetString) 可提高效率。
string.Equals(string)方法逐个char进行比较，效率相对较低。


假如他的这个targetString是用string.Concat拼出来的,用对象比较的方式不太妥吧,我觉得String重写==是有意义的.

用string.Concat拼出来的string也没有问题，可以试一下。
2009-09-19 08:48 | 鹤冲天       

#62楼 　回复　引用　查看　  

view source
print ?
126        public static String[] Concat(params String[][] ids)


3.0有hash set 不必用hash table
hashValues.Add(ids[i][j], ids[i][j]); 有点浪费


而且你对所有的数组操作都是基于两次循环
一次放入一个set 一次在set中操作
在重复的多次操作中 可能会太多重复操作
比如 在数组中去掉"a" "b" "c"...."X","Y","Z"
就要执行52*2个循环

相比之下linq 的思想: 利用yeild 和验证代理 只需要一次循环
效率好得多
2009-09-19 10:45 | 韦恩卑鄙       

#63楼[楼主] 　回复　引用　查看　  

@韦恩卑鄙

重复的数据能自动过滤？我主要是想把重复的数据合并掉，例如
a,b,c + b,c,d = a,b,c,d 为了达到这个效果进行了2次循环对比。
虚心向大师请教。
2009-09-19 10:49 | 吉日嘎拉>不仅权限设计       

#64楼 　回复　引用　查看　  

关于合并部分

hashset本身和hashtable一样 它是个简化的只有key的hashtable 而且是泛型 所以速度必然快一点点

用 linq to object 的话 可以简单的把所有东西全部 union 以后distinct

性能不见得最好 但是如果是配合其他查询的状况 比如 where 和sort等 延迟执行的枚举可以把大量循环操作变成一个枚举器的遍历 仍然是最好的选择
2009-09-19 10:54 | 韦恩卑鄙       

#65楼 　回复　引用　查看　  

view source
print ?
1var a = new string[] { "a", "b", "c" };
2var b = new string[] { "a", "g", "c" };
3var c = new string[] { "a", "b", "d" };
4var x = a.Union(b).Union(c).Distinct().ToArray() ;
5Array.ForEach(x,s=> Console.WriteLine(s)); 
6Console.ReadKey();
2009-09-19 11:02 | 韦恩卑鄙       

#66楼 　回复　引用　查看　  

view source
print ?
01var a = new string[] { "a", "b", "c" };
02var b = new string[] { "a", "g", "c" };
03var c = new string[] { "a", "b", "d" };
04var x = new HashSet<string>();
05  
06Array.ForEach(a,s=> x.Add (s));
07Array.ForEach(b, s => x.Add(s));
08Array.ForEach(c, s => x.Add(s));
09Array.ForEach(x.ToArray(), s => Console.WriteLine(s));
10Console.ReadKey();

hash set版本
2009-09-19 11:06 | 韦恩卑鄙       

#67楼 　回复　引用　查看　  

List<string> 都可以实现你的这些功能，为什么要用数组自己实现呢？你觉得你的实现比微软工程师写的东西更好？

另外，你不是一直倡导咨询收费的吗？
2009-09-19 11:52 | kiler       

#68楼[楼主] 　回复　引用　查看　  

@kiler
大家都觉得我写的不是技术文章，也没分享的成分，我就贴贴代码出来，互相交流切磋，若谁愿意给我整体的检查代码，指出改进的地方，我也当然愿意付费的，我又不是不肯付费。
2009-09-19 12:07 | 吉日嘎拉>不仅权限设计       

#69楼[楼主] 　回复　引用　查看　  

(14) 常用管理类软件需求征集 -- 组织机构管理
http://www.cnblogs.com/jirigala/archive/2009/08/27/1555358.html


本功能组件愿意支付费用完善的部分为如下：

1。功能改进，的确有道理，的确可以提高效率，用户使用起来会很友善的功能。
2。打印功能完善，有报表输出的。
3。精巧的屏幕打印功能（就是直接打印输出当前窗体）。
4。实现导入功能部分，功能稳定好用，思路严禁。
5。快捷键的完善，表名字段名设计得更合理命名更有道理的。
6。页面展示效果能明显改进的。

以上每个功能改进至少愿意支付100元人民币，或者更多，有兴趣的可以跟我谈。

总不至于每个功能收费我1万吧？
2009-09-19 12:08 | 吉日嘎拉>不仅权限设计       

#70楼 　回复　引用　查看　  

引用kiler：
List<string> 都可以实现你的这些功能，为什么要用数组自己实现呢？你觉得你的实现比微软工程师写的东西更好？

另外，你不是一直倡导咨询收费的吗？

这个list<string>提议可真是大大的外行了
2009-09-19 14:01 | 韦恩卑鄙       

#71楼 　回复　引用　查看　  

引用韦恩卑鄙：
引用kiler：
List<string> 都可以实现你的这些功能，为什么要用数组自己实现呢？你觉得你的实现比微软工程师写的东西更好？

另外，你不是一直倡导咨询收费的吗？

这个list<string>提议可真是大大的外行了

请问如何外行，不就是要实现
bool Exists(String[] ids, String targetString)
String[] Concat(params String[][] ids)
String[] Remove(String[] ids, String id)
这几个方法吗，用List<string>解决这些问题有何不好，没事浪费时间自己去整些算法有啥用，你能提高多少效率？
写C#不是写C，要的开发效率，不是用来做研究的。
2009-09-19 19:45 | kiler       

#72楼 　回复　引用　查看　  

@kiler
Exists 和remove 在list<T>中 只要超过8个元素 与hashset就有明显差距

这是为什么大多数了解基本hash表算法的人使用hashtable和dictionary利用key collection 加速运算
也是为什么3.0要增加hashset 来满足大家这一需求

list也许能满足初级需求 用dic和hashtabel也许不美观 但是放着hashset不用就是拿着不知道当个性了。
2009-09-19 22:06 | 韦恩卑鄙       

#73楼 　回复　引用　查看　  

尤其是 在没有反编译研究实现之前 就乱说“你觉得你的实现比微软工程师写的东西更好？”这叫屁话

屁话不是侮辱人的词语

表示 bad smell & meaningless
2009-09-19 22:08 | 韦恩卑鄙       

#74楼 　回复　引用　查看　  

引用韦恩卑鄙：
尤其是 在没有反编译研究实现之前 就乱说“你觉得你的实现比微软工程师写的东西更好？”这叫屁话

屁话不是侮辱人的词语

表示 bad smell & meaningless


不知道你为啥那么激动，我起先想表达的意思只不过是说用系统的东西就可以了，没有必要自己写东西实现，不管是用HashSet<string>或者还是用List<string>好，都是调用.Net framework本身的东西，而不是自己去实现算法，ok，我承认我举得例子很糟糕，List<string>的性能是HashSet<string>的1/100,这样是否满意？
2009-09-20 16:46 | kiler       

#75楼[楼主] 　回复　引用　查看　  

@kiler

技术上的争论，还好，会比较激烈一些。
2009-09-20 17:00 | 吉日嘎拉>不仅权限设计       

#76楼 　回复　引用　查看　  

查询用List<T>即可
其他操作 Hash
2009-09-21 10:34 | CrazyAbel       

#77楼 　回复　引用　查看　  

PS一下
最初创建List<T>时可能稍稍消耗点内存
及时TrimExcess即可
2009-09-21 10:42 | CrazyAbel       

#78楼 　回复　引用　查看　  

该篇未找到错别字
jirigala
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值