lqc自用 list处理

   /// <summary>
   /// List数据类型辅助处理类
   /// </summary>
   public static class listHelper
   {

       /// <summary>
       /// Clones the specified list.
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="List">The list.</param>
       /// <returns>List{``0}.</returns>
       public static List<T> Clone<T>(object List)
       {
           using (Stream objectStream = new MemoryStream())
           {
               IFormatter formatter = new BinaryFormatter();
               formatter.Serialize(objectStream, List);
               objectStream.Seek(0, SeekOrigin.Begin);
               return formatter.Deserialize(objectStream) as List<T>;
           }
       }

       /// <summary>
       /// 一维List转二维数组
       /// </summary>
       /// <remarks>
       /// 因为二维数据定义后赋值比较麻烦，可以用本方法把一个list数据转为一个二维数组
       /// </remarks>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <param name="columns"></param>
       /// <returns></returns>
       public static T[,] listToArray2<T>(this List<T> data, int columns)
       {
           var row = data.Count / columns;
           var ary = new T[row, columns];
           int js1 = 0;
           for (int i = 0; i < row; i++)
           {
               for (int k = 0; k < columns; k++)
               {
                   if (js1 < data.Count)
                       ary[i, k] = data[js1];
                   else
                       ary[i, k] = default(T);
                   ++js1;
               }
           }
           return ary;
       }

       /// <summary>
       /// 返回指定列数据，出错返回null
       /// </summary>
       /// <typeparam name="T">任意数值类型</typeparam>
       /// <param name="data">参数data为一维List数据源，它表示了一个二维数据表的数据</param>
       /// <param name="columns">一行有几列？</param>
       /// <param name="selColNo">要选择第几列？</param>
       /// <returns>返回指定列的数据。出错返回null</returns>
       public static List<T> getColumnData<T>(this List<T> data,int columns,int selColNo)
       {
           var ary = data.listToArray2(columns);
           var row = ary.Rank;
           var col = ary.GetLength(1);
           if (selColNo > col || selColNo < 0) return null;
           var list = new List<T>();
           for(int i=0;i<row;i++)
           {
               list.Add(ary[i, selColNo]);
           }
           return list;
       }

       /// <summary>
       /// 返回指定行数据，出错返回null
       /// </summary>
       /// <typeparam name="T">任意数值类型</typeparam>
       /// <param name="data">参数data为一维List数据源，它表示了一个二维数据表的数据</param>
       /// <param name="columns">一行有几列？</param>
       /// <param name="selRowNo">要选择第几行？</param>
       /// <returns>返回指定行的数据。出错返回null</returns>
       public static List<T> getRowData<T>(this List<T> data, int columns, int selRowNo)
       {
           var ary = data.listToArray2(columns);
           var row = ary.Rank;
           var col = ary.GetLength(1);
           if (selRowNo > row || row < 0) return null;
           var list = new List<T>();
           for (int i = 0; i < row; i++)
           {
               if (i == selRowNo)
               {
                   for (int k = 0; k < col; k++)
                       list.Add(ary[i, k]);
                   break;
               }
           }
           return list;
       }

       /// <summary>
       /// 由中值分类数据, 小于中值的分类型Item1,大于中值的分类到Item2
       /// <para>异常: Exception</para>
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="list"></param>
       /// <param name="midData"></param>
       /// <returns></returns>
       public static Tuple<List<T>, List<T>> classifyDataByMidValue<T>(this List<T> list, double midData)
       {
           try
           {
               List<T> topData = new List<T>();
               List<T> bottomData = new List<T>();
               foreach (var m in list)
               {
                   if (double.Parse(m.ToString()) > midData)
                       bottomData.Add(m);
                   else
                       topData.Add(m);
               }
               return new Tuple<List<T>, List<T>>(topData, bottomData);
           }
           catch(Exception ex)
           {
               throw ex;
           }
       }

       /// <summary>
       /// 求List的平均值
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static double avg<T>(this List<T> data)
       {
           try
           {
               double a = 0;
               foreach (var m in data)
               {
                   a += double.Parse(m.ToString());
               }
               return a/data.Count;
           }
           catch (Exception ex)
           {
               throw ex;
           }
       }

       /// <summary>
       /// 取数值类型List列表的最大元素值
       /// <para>异常: Exception</para>
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static T max<T>(this List<T> data)
       {
           try
           {
               T max =data[0];
               foreach (var m in data)
               {
                   if (double.Parse(m.ToString()) > double.Parse(max.ToString())) max = m;
               }
               return max;
           }
           catch(Exception ex)
           {
               throw ex;
           }
       }

       /// <summary>
       /// T数组转List T
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static List<T> toList<T>(this T[] data)
       {
           return data.ToList<T>();
       }

       /// <summary>
       /// 求T数组的最大元素
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static T max<T>(this T[] data)
       {
           try
           {
               T max = data[0];
               foreach (var m in data)
               {
                   if (double.Parse(m.ToString()) > double.Parse(max.ToString())) max = m;
               }
               return max;
           }
           catch (Exception ex)
           {
               throw ex;
           }
       }

       /// <summary>
       /// 取数值类型List列表的最小元素
       /// <para>异常: Exception</para>
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static T min<T>(this List<T> data)
       {
           try
           {
               T min =data[0];
               foreach (var m in data)
               {
                   if (double.Parse(m.ToString()) < double.Parse(min.ToString())) min = m;
               }
               return min;
           }
           catch(Exception ex)
           {
               throw ex;
           }
       }

       /// <summary>
       /// 取数值类型T数组的最小元素
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static T min<T>(this T[] data)
       {
           try
           {
               T min = data[0];
               foreach (var m in data)
               {
                   if (double.Parse(m.ToString()) < double.Parse(min.ToString())) min = m;
               }
               return min;
           }
           catch (Exception ex)
           {
               throw ex;
           }
       }

       /// <summary>
       /// 生成List,值的逗号分隔字符串
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static string getCommaString<T>(this List<T> data)
       {
           var sb1 = new StringBuilder();
           for (int i = 0; i < data.Count; i++)
           {
               sb1.Append(data[i]);
               if (i < data.Count - 1) sb1.Append(",");
           }
           return sb1.ToString();
       }

       /// <summary>
       /// 得到指定符号结尾的串
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <param name="endingChar"></param>
       /// <returns></returns>
       public static string getdAssignCharSeparateString<T>(this List<T> data,string endingChar)
       {
           var sb1 = new StringBuilder();
           for (int i = 0; i < data.Count; i++)
           {
               sb1.Append(data[i]);
               if (i < data.Count - 1) sb1.Append(endingChar);
           }
           return sb1.ToString();
       }

       public static string getShuString<T>(this List<T> data)
       {
           var sb1 = new StringBuilder();
           for (int i = 0; i < data.Count; i++)
           {
               sb1.Append(data[i]);
               if (i < data.Count - 1) sb1.Append("|");
           }
           return sb1.ToString();
       }

       /// <summary>
       /// 返回list项目加回车换行的字符串
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static string getEnterString<T>(this List<T> data)
       {
           var sb1 = new StringBuilder();
           for (int i = 0; i < data.Count; i++)
           {
               sb1.Append(data[i]);
               if (i < data.Count - 1) sb1.Append("\r\n");
           }
           return sb1.ToString();
       }

       /// <summary>
       /// 生成List,值的换行分隔的字符串
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <returns></returns>
       public static string getNewLineString<T>(this List<T> data)
       {
           var sb1 = new StringBuilder();
           for (int i = 0; i < data.Count; i++)
           {
               sb1.Append(data[i]);
               if (i < data.Count - 1) sb1.Append(Environment.NewLine);
           }
           return sb1.ToString();
       }

       /// <summary>
       /// 把二维List转为一维数据结构
       /// </summary>
       /// <param name="data"></param>
       /// <returns></returns>
       public static IList<Queue<double>> ListToQueue(this List<List<double>> data)
       {
           var ary1 = new List<Queue<double>>();

           foreach (var m in data)
           {
               var qAry = new Queue<double>(m.Count);
               foreach (var k in m)
               {
                   qAry.Enqueue(k);
               }
               ary1.Add(qAry);
           }
           return ary1;
       }

       /// <summary>
       /// 取二维List最大值
       /// </summary>
       /// <param name="data"></param>
       /// <returns></returns>
       public static double getMax(this List<List<double>> data)
       {
           var listMax = new List<double>();
           data.ForEach(delegate(List<double> d)
           {
               listMax.Add(d.Max());
           });
           return listMax.Max();
       }

       /// <summary>
       ///  取二维List最小值
       /// </summary>
       /// <param name="data"></param>
       /// <returns></returns>
       public static double getMin(this List<List<double>> data)
       {
           var listMin = new List<double>();
           data.ForEach(delegate(List<double> d)
           {
               listMin.Add(d.Min());
           });
           return listMin.Min();
       }

       /// <summary>
       /// 取按列排序的数据列表. 一般数据按行读取,如果要按列统计则可调用本函数,取得列排列的数据列表
       /// </summary>
       /// <param name="data"></param>
       /// <returns></returns>
       public static List<List<double>> GetVerticalData(this List<List<double>> data)
       {
           var colAry = new List<List<double>>();
           foreach (var m in data[0])
           {
               colAry.Add(new List<double>());
           }

           for (int i = 0; i < data[0].Count; i++)
           {
               for (int k = 0; k < data.Count; k++)
               {
                   colAry[i].Add(data[k][i]);
               }
           }
           return colAry;
       }

       /// <summary>
       /// 把二维的Queue转为List
       /// </summary>
       /// <param name="data"></param>
       /// <returns></returns>
       public static List<List<double>> QueueToList(this IList<Queue<double>> data)
       {
           var ary = new List<List<double>>();
           foreach (var m in data)
           {
               var buf = new List<double>();
               foreach (var k in m)
               {
                   buf.Add(k);
               }
               ary.Add(buf);
           }
           return ary;
       }

   }