.net字符串数组查找方式效率比较

下面是代码:

 static void Main(string[] args)
        {
            string[] arr = new string[] { "AAA", "BBBB", "CCCC", "DDDD", "EEEEEE", "ffffff", "ggggggg", "hhhhhh", "iii", "", "jjj", "kkk" };
            string findStr = "kkk";
            for (int i = 0; i < arr.Length; i++)
            {
                if (object.ReferenceEquals(findStr, arr[i]))
                    Console.Write(" true1 ");
            }
            Console.WriteLine();
            Console.Write("input string kkk :");

            string inputStr = Console.ReadLine();

            if (CompareStringInArrar( inputStr, arr))
            {
                Console.WriteLine(" true2 ");
            }
            ///////////////////////
            Console.WriteLine("一千万次字符串数组元素查找:");
            System.Threading.Thread.Sleep(3000);

            long ticks = DateTime.Now.Ticks;
            for (int i = 0; i < 10000000; i++)
            {
                CompareStringInArrar(inputStr, arr);
            }
            Console.WriteLine("自定义数组查找(Ticks):              {0}", DateTime.Now.Ticks - ticks);
            ////////////////////////////////////////
            System.Threading.Thread.Sleep(3000);

            ticks = DateTime.Now.Ticks;
            for (int i = 0; i < 10000000; i++)
            {
                FindStringInArrar0(ref findStr, arr);
            }
            Console.WriteLine("直接对象地址相等进行数组查找(Ticks):{0}", DateTime.Now.Ticks - ticks);
            ///////////////////////////////////
            System.Threading.Thread.Sleep(3000);

            ticks = DateTime.Now.Ticks;
            for (int i = 0; i < 10000000; i++)
            {
                FindStringInArrar(ref inputStr, arr);
            }
            Console.WriteLine("直接遍历进行数组查找(Ticks):        {0}", DateTime.Now.Ticks - ticks);

            ///////////////////////////////////
            System.Threading.Thread.Sleep(3000);

            ticks = DateTime.Now.Ticks;
            for (int i = 0; i < 10000000; i++)
            {
                CompareStringInArrar2( inputStr, arr);
            }
            Console.WriteLine("混合数组查找(Ticks):                {0}", DateTime.Now.Ticks - ticks);

           Console.Read();
            //DBMethod();
        }

        private static bool FindStringInArrar0(ref string inputStr, string[] arr)
        {
            for (int j = 0; j < arr.Length; j++)
            {
                if (object.ReferenceEquals(inputStr, arr[j]))
                    return true;
            }
            return false;
        }

        private static bool FindStringInArrar(ref string inputStr, string[] arr)
        {
            for (int j = 0; j < arr.Length; j++)
            {
                if (inputStr == arr[j])
                    return true;
            }
            return false;
        }

        private static bool CompareStringInArrar( string inputStr, string[] arr)
        {
            //char[] inputCharArr = inputStr.ToCharArray();
            int length = inputStr.Length;
            bool flag = true;
            //string strTemp = null;
            for (int i = 0; i < arr.Length; i++)
            {
                //strTemp = arr[i];
                if (length == arr[i].Length)
                {
                    flag = true;
                    for (int j = 0; j < length; j++)
                    {
                        if (inputStr[j] != arr[i][j])
                        {
                            flag = false;
                            break;
                        }
                    }
                    if (flag)
                        return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 混合查找
        /// </summary>
        /// <param name="inputStr"></param>
        /// <param name="arr"></param>
        /// <returns></returns>
        private static bool CompareStringInArrar2(string inputStr, string[] arr)
        {
            //char[] inputCharArr = inputStr.ToCharArray();
            int length = inputStr.Length;
            bool flag = true;
            //string strTemp = null;
            for (int i = 0; i < arr.Length; i++)
            {
                if (object.ReferenceEquals(inputStr, arr[i]))
                    return true;
                //strTemp = arr[i];
                if (length == arr[i].Length)
                {
                    flag = true;
                    for (int j = 0; j < length; j++)
                    {
                        if (inputStr[j] != arr[i][j])
                        {
                            flag = false;
                            break;
                        }
                    }
                    if (flag)
                        return true;
                }
            }
            return false;
        }

但是通常比较都需要忽略大小写比较,所以不能单纯使用这种方式比较,用下面的测试代码:

class Program
    {
        static void Main(string[] args)
        {
            string A = "124Abc";
            string B = "2345b";
            string C = "124abce";
            Console.WriteLine("input string(123Abc):");
            string D = Console.ReadLine();
            string E = "124Abc";

            long ticks = 0;
            long ticks2 = 0;
            long ticks3 = 0;
            long ticks4 = 0;
            long ticks5 = 0;

            Stopwatch sw = Stopwatch.StartNew();
            //预热
            for (int i = 0; i < 1000000; i++)
            {
                bool b1 = string.Compare(A, B, StringComparison.OrdinalIgnoreCase) == 0;
            }
            //开始
            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                bool b1 = string.Compare(A, D, StringComparison.OrdinalIgnoreCase) == 0;
            }
            ticks = sw.ElapsedTicks;

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                bool b2 = string.Equals(A, C, StringComparison.OrdinalIgnoreCase);
            }
            ticks2 = sw.ElapsedTicks;

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                bool b2 = string.Equals(A, D, StringComparison.OrdinalIgnoreCase);
            }
            ticks3 = sw.ElapsedTicks;

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                bool b2 = string.Equals(A, E, StringComparison.OrdinalIgnoreCase);
            }
            ticks4 = sw.ElapsedTicks;

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                bool b2 = A.Length== C.Length && string.Equals(A, C, StringComparison.OrdinalIgnoreCase);
            }
            ticks5 = sw.ElapsedTicks;

            Console.WriteLine("{0},\r\n{1},\r\n{2},\r\n{3},\r\n{4}\r\n", ticks, ticks2, ticks3, ticks4, ticks5);
            Console.Read();
        }
    }

最后得出结论,最后一种方式最快,原因在于首先判断了长度,如果不是一样的长度直接跳过比较,下面是测试数据:

input string(123Abc):
123Abc
87806,
15255,
58227,
7569,
1939
时间: 2024-10-24 10:42:50

.net字符串数组查找方式效率比较的相关文章

一个在字符串中查找多个关键字的函数strstrs(三种不同算法实现及效率分析)

平时项目中有时需要用到在字符串中搜索两个或更多的关键字的情景.例如:将字符串"ab|cd#ef|"按竖线或者井号做分隔 如果是大项目,一般会采用正则表达式做处理.但有时写个小程序,不想因此引进一个正则库,所以我自己写了一个支持多关键字版本的字符串查找函数strstrs 函数说明: 1 #include <stdio.h> 2 #include <windows.h> 3 4 #ifndef IN 5 #define IN 6 #endif 7 8 //函数说明:

字符串数组的两种定义方式

C++实现字符串数组的两种方式 1.常用的方法 #include <iostream> #include <string> using namespace std; int main() { string str[]={"hello", "string", "world"}; int str_size=sizeof(str)/sizeof(string); cout<<"size of str is

9.11排序与查找(五)——有个排序后的字符串数组,其中散布着一些空字符串,找出给定字符串的位置

/** * 功能:有个排序后的字符串数组,其中散布着一些空字符串,找出给定字符串的位置. */ /** * 思路:对二分查找法做修改,与mid比较的地方,如果mid为空字符串,则将mid换到离它最近的非空字符串的位置. * @param strings * @param str * @return */ public static int search(String[] strings,String str){ if(strings==null||str==null||str=="")

9.11排序与查找(二)——对字符串数组进行排序,将所有的变位词排在相邻的位置

/** * 功能:对字符串数组进行排序,将所有的变位词排在相邻的位置. */ 两种方法: 方法一: /** * 思路:套用排序算法,并修改比较器.这里比较器用来指示两个字符串胡伟变位词就是相等的. * @param array */ public static void sort(String[] array){ Arrays.sort(array, new AnagramComparator()); } class AnagramComparator implements Comparator

利用快慢下标操作字符串数组

1.去除掉多余的空格: e.g. Before:   Life___is__short___I___use___python_'\0'(下划线为空格) After:  Life_is_short_I_use_python'\0' (去除掉多余的空格) 去掉空格比较简单,我们可以通过逐个判断字符,如果有连续的空格就使数组左移直到只剩一个空格,可是这么做效率十分低下; 前面学习过利用快慢下标的方法实现快排思想,这里也可以采用类似的方法 : 对于删除后的数组,长度将减少或者不变,则指向删除后数组的下标

三种javascript数组搜索的效率对比

1.背景 在写js的时候经常有查询一个字符串数组中是否存在某个值的需求,可以用for in或者for i++或者直接arr.join(',').indexOf()三种方式..最后一种代码最少因此用的最多,但是效率如何自己也没有把握..所以今天就特地拿来测试一下. 2.测试代码 //构造一个数组 var arr=[]; for(var i=0;i<=1000000;i++){ arr.push('abcdefghigk'+i); } var v='abcdefghigk1000000';//需要比

C++ 字符串指针与字符串数组

在做面试100题中第21题时,发现char *astr="abcdefghijk\0";和char astr[]={"abcdefghijk"};有点区别,以前一直以为是一样的,但是在该程序中采用字符串指针运行一直出错.后来在网上查查,果然发现大大的不同. 展示如何出错 分析:当你需要修改字符串时,采用指针指向该字符串编译通过但是运行出错,而采用字符串数组时不会出现这样的问题.我们知道计算机有堆栈空间供编程人员使用,第一行,astr为栈上分配的一个指针,而右边在堆上

golang 几种字符串的连接方式

最近在做性能优化,有个函数里面的耗时特别长,看里面的操作大多是一些字符串拼接的操作,而字符串拼接在 golang 里面其实有很多种实现. 实现方法 1. 直接使用运算符 func BenchmarkAddStringWithOperator(b *testing.B) { hello := "hello" world := "world" for i := 0; i < b.N; i++ { _ = hello + "," + world

数据结构(六)查找---有序表查找(三种查找方式:折半,插值,斐波拉契查找)

前提 有序表查找要求我们的数据是有序的,是排序好的,我们只需要进行查找即可 我们下面将介绍折半查找(二分查找),插值查找,斐波那契查找 一:折半查找 (一)定义 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法.但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列. (二)查找过程 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关