LINQ标准查询操作符详解

      LINQ提供的便利：

      1）使用一种简化的方式编写查询语句；

      2）通过消除运行时错误和捕捉编译时错误减少开发时间；

      3）直接在开发语言中提供对LINQ的IntelliSense和调试支持；

      4）消除关系数据和面向对象开发之间的障碍；

      5）提供与数据源无关的统一查询语法。

      LINQ的一大特性是可以对多种数据源查询，而且查询的语法相同，这为开发人员处理不同的数据源的数据提供了极大的便利。

      LINQ 能查询的数据有但不限于：

      1）对象，LINQ to Objects。比如集合、数组、字符串等等。

      2）关系数据，分为 LINQ to DataSet 和 LINQ to SQL，前者用于 DataSet 查询，后者用于 SQL Server 数据库查询。

      3）XML，LINQ to XML。

      二、 操作符和LINQ 

      下面代码演示从一个字符串数组中获取所有以"s"结尾的字符串，并打印。
 

string [] fruits  =   new   string []
                                 {
                                      " Apple " ,  " Apricot " ,  " Arbutus " ,  " Banana " ,  " Bennet " ,  " Betelnut " ,  " Betelnut " ,
                                      " Black brin "
                                 };
            IEnumerable < string >  val  =  from fruit  in  fruits  where  fruit.EndsWith( " s " ) select fruit;
             foreach  ( string  s  in  val)
            {
                Console.WriteLine(s  +   " \n " );
            }

   

      这是一个简单的LINQ表达式，其中where和select是LINQ众多标准查询操作符中的两个，select是投影操作符，它在某个系列（即实现了Ienumerable<string>接口的对象上）上进行投影，where是限制操作符类型，类似我们sql语句中的where，用于过滤某个系列。局部变量fs实现了具有遍历功能的Ienumerable<string>接口。LINQ中提供了很多和where、select这样的标准查询操作符，这些查询操作符提供了很多功能，如过滤、排序、分组、聚合、转换等功能，LINQ包括两个标准查询操作符集合，一个集合用于操作IEnumerable<T>类型的对象，另外一个集合则是用于操作IQueryable<T>类型的对象。这些操作符由Enumerable和Queryable类的静态方法组成。如Enumerable类提供了Select、Where等查询操作符的静态方法，更详细的了解，可以查阅MSDN，网址：http://msdn.microsoft.com/zh-cn/library/bb341635.aspx。
       
       可能有部分读者看了Enumerable和Queryable类提供了的静态方法，如Enumerable类中提供了where的方法为：

     

  public   static  IEnumerable < TSource >  Where < TSource > (
     this  IEnumerable < TSource >  source,
    Func < TSource,  bool >  predicate
)

      在观照from fruit in fruits where fruit.EndsWith("t") select fruit这样的查询表达式会有些疑惑，因为我们通常使用静态方法都是这样用的：方法名.静态方法(方法参数)，但是在上面查询表达式中，这些静态方法却被当做关键字的方式来使用。其实LINQ提供了查询语法和方法语法这两种语法来编写查询功能，像上面是查询语法，实现var fs = from fruit in fruits where fruit.EndsWith("t") select fruit这样的查询功能，我们还可以用LINQ提供的方法语法来实现：
var fs = fruits.where(f=>f.EndsWith(“t”));


     可见在方法语法使用标准查询操作符和Enumerable类提供的静态方法是吻合的。写过T-SQL语句的读者对于LINQ的查询语法都很容易理解和阅读，这是人容易理解的方式，但其实CLR并不理解查询语法，CLR能够理解方法语法，因此编译一个LINQ的查询表达式时，查询语法将会被转换为方法语法。

      三、 LINQ操作符类型类型


      可根据标准查询操作符的操作“类型”进行分类，如把它们分成投影、限制、排序、联接、分组、串联、聚合、集合、生成、转换、元素、相等、量词、分割等。

类型 操作符名称
投影操作符 Select,SelectMany
限制操作符 Where
排序操作符 OrderBy,OrderByDescending,ThenBy,ThenByDescending,Reverse
联接操作符 Join,GroupJoin
分组操作符 GroupBy
串联操作符 Concat
聚合操作符 Aggregate,Average,Count,LongCount,Max,Min,Sum
集合操作符 Distinct,Union,Intersect,Except
生成操作符 Empty,Range,Repeat
转换操作符 AsEnumerable,Cast,OfType,ToArray,ToDictionary,ToList,ToLookup
元素操作符 DefaultIfEmpty,ElementAt,ElementAtOrDefault,First,Last,FirstOrDefault, LastOrDefault,Single,SingleOrDefault
相等操作符 SequenceEqual
量词操作符 All,Any,Contains
分割操作符 Skip,SkipWhile,Take,TakeWhile

     

        为便于下面代码的演示，这里先定义一些公共代码。我们定义一个学生类Student，一个学校类School，然后定义一个Student的集合类Sudents和一个学校的集合schools。

///   <summary>
     ///  学生类
     ///   </summary>
     public   class  Student
    {
         public   int  StuId {  get ;  set ; }
         public   string  Name {  get ;  set ; }
         public   int  Age {  get ;  set ; }
         public   string  Class {  get ;  set ; }
         public   int  SchoolId {  get ;  set ; }
    }

     ///   <summary>
     ///  学校类
     ///   </summary>
     public   class  School
    {
         public   int  SchoolId {  get ;  set ; }
         public   string  SchoolName {  get ;  set ; }
    }
   static   void  Main( string [] args)
        {
             IList < School >  schools  =   new  List < School > ();
            schools.Add( new  School() { SchoolId  =   1 , SchoolName  =   " BeiJing Middle School  "  });
            schools.Add( new  School() { SchoolId  =   2 , SchoolName  =   " ShangHai Middle School  "  });
            schools.Add( new  School() { SchoolId  =   8 , SchoolName  =   " GuangZhou Middle School  "  });

            IList < Student >  students  =   new  List < Student > ();
            students.Add( new  Student() { StuId  =   1 , Name  =   " Li Lei " , Age  =   9 , Class  =   " Grade Three " , SchoolId  =   1  });
            students.Add( new  Student() { StuId  =   2 , Name  =   " Han Meimei " , Age  =   9 , Class  =   " Grade Three " , SchoolId  =   1  });
            students.Add( new  Student() { StuId  =   3 , Name  =   " Li Ming " , Age  =   6 , Class  =   " Grade One " , SchoolId  =   2  });
            students.Add( new  Student() { StuId  =   4 , Name  =   " Zou Qi " , Age  =   7 , Class  =   " Grade One " , SchoolId  =   2  });
            students.Add( new  Student() { StuId  =   5 , Name  =   " Wang Long " , Age  =   7 , Class  =   " Grade One " , SchoolId  =   1  });

        }

      1、投影操作符
      1） Select 将序列中的每个元素投影到新表中。
      代码演示从students数据源中查询年龄为9岁的学生，使用Select操作符从返回结果序列中返回Name和Class两列。

     

 var studentSelect  =  from s  in  students  where  s.Age  ==   9  select  new  { s.Name, s.Class };
            var studentS  =  students.Where(s  =>  s.Age  ==   9 );
             foreach  (var s  in  studentSelect)
            {
                Console.WriteLine(s.Name  +   " \n " );
            }

      输出结果如下：

      Li Lei

      Han Meimei

     2） SelectMany 将序列的每个元素投影到 IEnumerable<T> 并将结果序列合并为一个序列。
     比如我们需要把students集合中每位学生的姓名组成一个单词系列（一个学生名字可能有多个单词组成），则可以使用SelectMany操作符。

    

var studentSelectMany  =  students.SelectMany(s  =>  s.Name.Split( '   ' ));
             foreach  ( string  s  in  studentSelectMany)
            {
                Console.WriteLine(s);
            }

     输出结果如下：

     Li
     Lei
     Han
     Meimei
     Li
     Ming
     Zou
     Qi
     Wang
     Long

     2、限制操作符
     1）Where 对序列中值进行过滤，它不启动查询的执行，也就是查询是延迟的，只有当枚举对象时where才应用到数据上

     下面示例从学生集合中过滤名叫LiLei的学生，代码如下：

     

 IEnumerable < Student >  studentWhere  =  students.Where(p  =>  p.Name.Equals( " Li Lei " ));
             foreach  (Student student  in  studentWhere)
            {
                Console.WriteLine(student.Name);
            }


     输出结果如下：

      Li Lei

     上面代码建立查询语句，但这个语句并没用立即执行，而是在后面用foreach遍历stu对象时，查询语句才是执行，这就是所谓的延迟执行。LINQ的查询语句执行有两种方式，一种是延迟执行，一种是立即执行。任何返回单个值的LINQ查询都会立即执行，如我们查询学生集合中年龄7岁的学生个数：var count = (from student in students where student.Age == 7 select student).Count();

     3、排序操作符
     1）OrderBy 该操作符对序列元素按照选定的键进行升序排序
     如对学生集合中的学生按照年龄进行升序排序：

    

 IEnumerable < Student >  studentOrderBy  =  from student  in  students orderby student.Age descending select student;
             foreach  (Student student  in  studentOrderBy)
            {
                Console.WriteLine(student.Name  +   "   "   +  student.Age);
            }

     输出结果如下：

     Li Lei 9
     Han Meimei 9
     Zou Qi 7
     Wang Long 7
     Li Ming 6

     2）OrderByDescending 这个操作符和OrderBy相反，它是对序列元素按选定的键进行降序排列

     如对学生集合中的学生按照年龄进行降序序排序：

    

 IEnumerable < Student >  studentOrderByDescending  =  from student  in  students orderby student.Age descending select student;
             foreach  (Student student  in  studentOrderByDescending)
            {
                Console.WriteLine(student.Name  +   "   "   +  student.Age);
            }

     输出结果如下：

      Li Lei 9
      Han Meimei 9
      Zou Qi 7
      Wang Long 7
      Li Ming 6

      3）ThenBy 该操作符实现序列元素按照次关键字进行升序排序
      如对学生集合中先按年龄排序再按姓名排序：

     

IEnumerable < Student >  studentThenBy  =  students.OrderBy(p  =>  p.Age).ThenBy(p  =>  p.Name);
             foreach  (Student student  in  studentThenBy)
            {
                Console.WriteLine(student.Name  +   " \t "   +  student.Age);
            }

      输出结果如下：

      Li Ming 6
      Wang Long       7
      Zou Qi  7
      Han Meimei      9
      Li Lei  9

     我们发现ThenBy操作符并不能在查询方法中使用只能在方法语法中使用。熟悉写SQL语句的读者可能会问：IEnumerable<Student> sds = students.OrderBy(p => p.Age).ThenBy(p => p.Name);和IEnumerable<Student> sds = students.OrderBy(p => p.Age).OrderBy(p => p.Name);这两个查询语句结果有区别吗？区别是前者是在对主关键字排序结果上对那些主关键字相同的元素应用ThenBy指定的次关键字进行排序，后者是在对第一个OrderBy指定的关键字升序排序的基础上对所有的元素进行第二个OrderBy指定的关键字进行升序排序，毫无疑问，后者第一个OrderBy其实对于结果是没有意义的，因为第二个OrderBy是针对全部元素的。

      4）ThenByDecending 该操作符和ThenBy相反，它按次关键字降序排序

     

IEnumerable < Student >  studentThenByDescending  =  students.OrderBy(p  =>  p.Age).ThenByDescending(p  =>  p.Name);
             foreach  (Student student  in  studentThenByDescending)
            {
                Console.WriteLine(student.Name  +   " \t "   +  student.Age);
            }

      输出结果如下：

      Li Ming 6
      Zou Qi  7
      Wang Long       7
      Li Lei  9
      Han Meimei      9

      5）Reverse 该操作符对序列中的元素进行反转（逆序）排序
      如把学生集合类按逆序输出学生姓名：

     

IEnumerable < Student >  studentThenReverse  =  students.Reverse();
             foreach  (Student student  in  studentThenReverse)
            {
                Console.WriteLine(student.Name);
            }

      输出结果如下：

      Wang Long
      Zou Qi
      Li Ming
      Han Meimei
      Li Lei

     4、联接操作符
     1）Join 该操作符类似T-SQL中的inner join ，一个序列通过Join根据匹配条件联接另外一个序列。

      如学生集合类根据SchoolId和学校集合类的SchoolId匹配联接，产生一个新的序列。

    

 var studentJoin  =  students.Join(schools, s  =>  s.SchoolId, c  =>  c.SchoolId,
                                   (s, c)  =>   new  { StudentName  =  s.Name, SchoolName  =  c.SchoolName });
             foreach  (var s  in  studentJoin)
            {
                Console.WriteLine( " StudentName:{0}\t SchoolName:{1} " , s.StudentName, s.SchoolName);
            }

      输出结果如下：

      StudentName:Li Lei       SchoolName:BeiJing Middle School
      StudentName:Han Meimei   SchoolName:BeiJing Middle School
      StudentName:Li Ming      SchoolName:ShangHai Middle School
      StudentName:Zou Qi       SchoolName:ShangHai Middle School
      StudentName:Wang Long    SchoolName:BeiJing Middle School

      2）GroupJoin 该操作符将主数据源的每一个元素和次数据源的相应的值（根据某个匹配条件）联接起来，返回一个具有层级的结果集
      下面代码演示了打印每一所学校名称，同时打印这所学校的学生的名称，代码如下：
  

 var studentGroupJoin  =  schools.GroupJoin(students, s  =>  s.SchoolId, c  =>  c.SchoolId,
                                   (ss, stus)  =>   new  { SchoolName  =  ss.SchoolName, Students  =  stus.Select(p  =>  p.Name) });
             foreach  (var s  in  studentGroupJoin)
            {
                Console.WriteLine(s.SchoolName  +   " \n " );
                 foreach  (var name  in  s.Students)
                {
                    Console.WriteLine( "    "   +  name);
                }
            }

    

      输出结果如下：

      BeiJing Middle School

      Li Lei
      Han Meimei
      Wang Long
      ShangHai Middle School

      Li Ming
      Zou Qi
      GuangZhou Middle School


      5、分组操作符
      1）GroupBy 该操作符根据一个指定的值将序列中的元素进行分组
      下面代码演示了学生集合中根据SchoolId进行分组，代码如下：

 var studentGroupBy  =  students.GroupBy(p  =>  p.SchoolId);
             foreach  (var st  in  studentGroupBy)
            {
                Console.WriteLine(st.Key  +   " \n " );
                 foreach  (var s  in  st)
                {
                    Console.WriteLine( "    "   +  s.Name);
                }
            }

      输出结果如下：
      1

          Li Lei
          Han Meimei
          Wang Long
      2

           Li Ming
           Zou Qi


      6、串联操作符
      1）Concat 该操作符将两个系列合并成一个系列
      下面代码演示将students的Name和schools中SchoolName合并成一个新的系列，代码如下：

  var studentConcat  =  students.Select(s  =>  s.Name).Concat(schools.Select(c  =>  c.SchoolName));
             foreach  (var st  in  studentConcat)
            {
                Console.WriteLine(st);

            }


       输出结果如下：
        Li Lei
        Han Meimei
        Li Ming
        Zou Qi
        Wang Long
        BeiJing Middle School
        ShangHai Middle School
        GuangZhou Middle School


        7、聚合操作符
        聚合操作符在一系列的值上执行特定的运算，并返回单个值，如执行求和求平均值等。
       1）Aggregate 该操作符将序列中的值进行累积并返回结果

       下面演示使用Aggregate操作符返回学生集合中所有的学生名字：
      

 var studentAggregate  =  students.Select(s  =>  s.Name).Aggregate((n, next)  =>  n  +   "  ,  "   +  next);
            Console.WriteLine(studentAggregate);

 

        输出结果如下：
        Li Lei , Han Meimei , Li Ming , Zou Qi , Wang Long


        2）Average 该操作符计算一个数值序列的平均值。注意它只能应用于数值数列
        下面代码演示计算学生集合中学生的平均年龄：

        

 var avgAge  =  students.Select(s  =>  s.Age).Average();
            Console.WriteLine(avgAge);


        输出结果如下：

        7.6


        3） Count 该操作符计算一个特定集合中元素的个数，返回结果是一个Int32类型的数值
       如计算学生集合中学生的个数：

       

var count  =  students.Count;
            Console.WriteLine(count);


       输出结果如下：

        5


       4）LongCount 该操作符和Count类似也是计算序列中元素的个数，所不同是返回的结果是一个Int64类型的值
    

 var longCount  =  students.LongCount();
            Console.WriteLine(longCount);

    

      输出结果如下：

       5


       5） Max 该操作符返回一个系列中的最大值。
       如计算学生集合中最大的年龄：

      

  var max  =  students.Max(p  =>  p.Age);
            Console.WriteLine(max);


       输出结果如下：

       9


       6） Min 该操作符和Max相反，返回的是一个序列中的最小值。
    

    var min  =  students.Min(p  =>  p.Age);
            Console.WriteLine(min);

   

        输出结果如下：6


        7）Sum 该操作符计算序列中选定值的总和。
        计算学生集合中年龄的总和：
   

 var sum  =  students.Sum(p  =>  p.Age);
            Console.WriteLine(sum);

    

        输出结果如下：

         38


      8、集合操作符
      集合操作符对元素的集合或序列的集合进行操作，并返回一个集合。
      1） Distinct 该操作符删除集合中重复值，返回的结果的元素是互不相同的
      如查询学生集合中的年龄有多少种。

 var ages  =  students.Select(p  =>  p.Age).Distinct();
             foreach  ( int  age  in  ages)
            {
                Console.WriteLine(age);
            }

      

      输出结果如下：
       9
       6
       7


      2）Union 该操作符返回两个系列中每个互不相同的元素，即两个集合的并集∪
      我们前面提到Concat操作符，Concat是返回两个集合的所有元素，Union则是返回互不相同的元素。

      如查询students的StuId和schools的SchoolId的并集，代码如下：
    

 var studentUnion  =  students.Select(s  =>  s.StuId).Union(schools.Select(c  =>  c.SchoolId));
             foreach  ( int  id  in  studentUnion)
            {
                Console.WriteLine(id);
            }

 

      输出结果如下：
      1 
      2
      3
      4
      5
      8

      3）Intersect 该操作符返回同时存在两个系列中的元素，也就是返回两个系列元素的交集∩
      如查询students的StuId和schools的SchoolId的交集，代码如下：

     

var studentIntersect  =  students.Select(s  =>  s.StuId).Intersect(schools.Select(c  =>  c.SchoolId));
             foreach  ( int  id  in  studentIntersect)
            {
                Console.WriteLine(id);
            }


      输出结果如下：
      1
      2


     4） Except 该操作符返回的是系列A有，但系列B没有的元素
     如查询students有的编号而schools没有的编号，代码如下：

  var studentExcept  =  students.Select(s  =>  s.StuId).Except(schools.Select(c  =>  c.SchoolId));
             foreach  ( int  id  in  studentExcept)
            {
                Console.WriteLine(id);
            }

     输出结果如下：
     3
     4
     5


     9、生成操作符
     生成操作符从现有系列的值中创建新的系列。
     1） Empty 该操作符返回一个指定类型的空的 IEnumerable<T>
     下面的代码示例演示如何使用 Empty<TResult>() 生成一个空 IEnumerable<T>。
      IEnumerable<decimal> empty = Enumerable.Empty<decimal>();
      下面的代码示例演示了 Empty<TResult>() 方法的一种可能的用法。将 Aggregate 方法应用于字符串数组的集合。仅当该数组包含四个或多个元素时，集合中的每个数组的元素被添加到结果的 IEnumerable<T> 中。Empty<TResult> 用于生成 Aggregate 的种子值，因为如果集合中没有包含四个或更多元素的数组，则只能返回空序列。

string [] names1  =  {  " Hartono, Tommy "  };
             string [] names2  =  {  " Adams, Terry " ,  " Andersen, Henriette Thaulow " ,
                                   " Hedlund, Magnus " ,  " Ito, Shu "  };
             string [] names3  =  {  " Solanki, Ajay " ,  " Hoeing, Helge " ,
                                   " Andersen, Henriette Thaulow " ,
                                   " Potra, Cristina " ,  " Iallo, Lucio "  };

            List < string [] >  namesList  =
                 new  List < string [] >  { names1, names2, names3 };


            IEnumerable < string >  allNames  =
                namesList.Aggregate(Enumerable.Empty < string > (),
                (current, next)  =>  next.Length  >   4   ?  current.Union(next) : current);

             foreach  ( string  name  in  allNames)
            {
                Console.WriteLine(name);
            }

     

     输出结果如下：
      Solanki, Ajay
      Hoeing, Helge
      Andersen, Henriette Thaulow
      Potra, Cristina
      Iallo, Lucio


      2） Range 该操作符创建一个数字序列的集合，它包含两个参数，第一个是序列的开始值，第二个参数是产生序列的个数
      下面代码演示创建一个从1到5的数字序列，然后每个数字乘以5： 

 var nums  =  Enumerable.Range( 1 ,  5 ).Select(n  =>  n  *   5 );
             foreach  ( int  num  in  nums)
            {
                Console.WriteLine(num);
            }

    

      输出结果如下：
       5
       10
       15
       20
       25

      

       3）Repeat 该操作符创建一个但值序列，将次值重复一定的次数。
       下面代码演示创建一个包含三个元素的序列，这些元素都是“test”，代码如下：

 var str  =  Enumerable.Repeat( " test " ,  3 );
             foreach  ( string  s  in  str)
            {
                Console.WriteLine(s);
            }


        输出结果如下：
        test
        test
        test


       10、转换操作符
       1）AsEnumerable 该操作符将查询的输入以IEnumerable<Of T>类型返回，也就是可以将实现了IEnumerable<Of T>的数据源转换为IEnumerable<Of T>类型本身

       许多类型都实现了IEnumerable。其中一部分还实现了与IEnumerable一模一样的公共方法。比如说，如果你有一个实现了Where方法的类型MyList（跟IEnumerable<T>一样），那么在MyList上调用Where将使用MyList的Where实现。如果先调用AsEnumerable方法然后再调用Where的话，你调用的就是IEnumerable的Where方法而不是MyList的。

   class  MyList < T >  : List < T >
    {

         public  IEnumerable < T >  Where(Func < T,  bool >  predicate)
        {
            Console.WriteLine( " 调用MyList的Where方法 " );
             return  Enumerable.Where( this , predicate);
        }
    }
pulic  void  AsE()
{
            MyList < string >  names  =
                 new  MyList < string >  {  " Li Lei " ,  " Han Meimei " ,  " Li Long " , 
                     " Wang Ming " ,  " Zou Qi " ,  " Chen Fei " ,  " Wang Tian "  };

             // 这里调用MyList的where方法
            IEnumerable < string >  query1  =
                names.Where(name  =>  name.Contains( " Li " ));
            Console.WriteLine(query1.Count());

             // 这里隐藏了MyList的where方法，而是调用了Enmerable的Where方法。
            IEnumerable < string >  query2  =
                names.AsEnumerable().Where(name  =>  name.Contains( " Li " ));

            Console.WriteLine(query2.Count());
}


       输出结果如下：
      调用MyList的Where方法
       2
       2


      2）Case 该操作符将IEnumerable集合中的元素转换为某种指定的类型。这样的好处就是通过提供必要的类型信息，可以将标准查询操作符应用在非泛型集合上

      如下面代码演示通过使用Cast操作符，可以将标准操作符应用于查询ArrayList类型对象的数据源（ArrayList没有实现IEnumerable<Of T>）

 ArrayList nameList  =   new  ArrayList();
            nameList.Add( " Li Lei " );
            nameList.Add( " Li Ming " );
            nameList.Add( " Han Meimei " );
            IEnumerable < string >  query  =  nameList.Cast < string > ().Where(name  =>  name.Contains( " Li " ));
             foreach  ( string  s  in  query)
            {
                Console.WriteLine(s);
            }


      输出结果如下：
      Li Lei
      Li Ming


      3) OfType 该操作符可以对一个序列进行指定类型的过滤
      下面代码演示从ArrayList对象中过滤可以转换为Int类型的元素，代码如下：

 ArrayList nameList2  =   new  ArrayList();
            nameList2.Add( 4 );
            nameList2.Add( " Li Ming " );
            nameList2.Add( " Han Meimei " );
            nameList2.Add( 1 );
            nameList2.Add( 2 );
            IEnumerable < int >  query3  =  nameList2.OfType < int > ();
             foreach  ( int  i  in  query3)
            {
                Console.WriteLine(i);
            }


       输出结果如下：
       4
       1
       2


      4）ToArray 该操作符实现从一个IEnumerable序列创建一个数组。该操作符会强制查询立即执行
      下面代码演示将students集合中讲学生名字转换为一个字符串数组：

 var studentToArray  =  students.Select(student  =>  student.Name).ToArray();
            Console.WriteLine(studentToArray.Count());

     

     输出结果如下：
      5


      5）ToDictionary 该操作符将序列分别转换为一对一的Dictionary<T Key,T Value>字典
      下面代码演示将students集合中序列转换为以StuId为Key的Dictionary<Int,Student>类型的对象，代码如下：

  var studentToDictionary  =  students.ToDictionary(st  =>  st.StuId);
             foreach  (KeyValuePair < int , Student >  keyValuePair  in  studentToDictionary)
            {
                Console.WriteLine( " Key:{0},Name:{1} " , keyValuePair.Key, keyValuePair.Value.Name);
            }

     

      输出结果如下：
      Key:1,Name:Li Lei
      Key:2,Name:Han Meimei
      Key:3,Name:Li Ming
      Key:4,Name:Zou Qi
      Key:5,Name:Wang Long


      6） ToList 该操作符将一个IEnumerable序列集合转换为List<Of T>对象，它使得查询立即执行
      下面代码将students集合中的学生姓名转换为一个类型为List<string>的字符串集合，代码如下：

List < string >  studenToList  =  (from student  in  students select student.Name).ToList();
             foreach  ( string  s  in  studenToList)
            {
                Console.WriteLine(s);
            }


       输出结果如下：
       Li Lei
       Han Meimei
       Li Ming
       Zou Qi
       Wang Long


      7）LookUp 该操作符将序列转换为一对多的LookUp<T Key,TElement Values>字典
      如以班级名称为主键，Values为该班级的所有学生，代码如下：

 var lookUp  =  students.ToLookup(st  =>  st.Class);
             foreach  (var grouping  in  lookUp)
            {
                Console.WriteLine(grouping.Key  +   " \n " );
                 foreach  (var student  in  grouping)
                {
                    Console.WriteLine( "    "   +  student.Name);
                }
            }

  
       输出结果如下：
       Grade Three

       Li Lei
       Han Meimei
       Grade One

       Li Ming
       Zou Qi
       Wang Long


      11、元素操作符
      元素操作符从一个系列返回单个特定的元素
      1）DefaultIfEmpty 该操作符将一个空集合替换为包含默认的单个值的集合。在返回序列为空集合时且又需要返回一些对象时，可以通过该操作符返回一个默认值
      如果查询students集合中年龄为5岁的学生，因为结果为空，可以指定一个默认值。代码如下所示：  

 var studentsDefaultIfEmpty  =  students.Where(s  =>  s.Age  ==   20 ).DefaultIfEmpty( new  Student() { Name  =   " 默认值 "  });
             foreach  (Student student  in  studentsDefaultIfEmpty)
            {
                Console.WriteLine(student.Name);
            }

      

     输出结果如下：
      默认值


      2） ElementAt 该操作符返回集合中给定索引处的元素
      如查询students集合中索引为1的元素，代码如下：    

  

 var studentEle  =  students.ElementAt( 1 );
            Console.WriteLine(studentEle.Name);

  

      输出结果如下：
      Han Meimei


      3）ElementAtOrDefault 该操作符返回指定索引处的元素

      如果该索引超出范围，则返回默认值，如果是引用类型返回为Null，如果是值类型则返回为0。如下面获取索引为100的学生，因为索引范围没有那么大，索引返回为null。         

 var studentEleD  =  students.ElementAtOrDefault( 100 );
            Console.WriteLine(studentEleD  ==   null   ?   " 返回默认值NULL "  : studentEleD.Name);


      输出结果如下：
      返回默认值null


      4）First 该操作符返回序列中的第一个元素
      如果源系列不包含任何元素，First方法将抛出一个System.InvalidOperationException
的异常。
     下面代码演示返回学生集合students的第一个元素。  

  var studentFirst  =  students.First();
            Console.WriteLine(studentFirst.Name);

      
     输出结果如下：
     Li Lei


      5）Last 与First操作符相反，该操作符返回序列中的最后一个元素
  

 var studentLast  =  students.Last();
            Console.WriteLine(studentLast.Name);

  

      输出结果如下：
      Wang Long


      6）FirstOrDefault 该 操作符类似First操作符，不同的是，如果没有发现任何元素则返回默认值，元素为引用类型默认值为null，值类型为0
     如查询students集合中学生年龄为20的学生的第一个，代码如下：

     

 var studentFirstD  =  students.Where(s  =>  s.Age  ==   20 ).FirstOrDefault();
            Console.WriteLine(studentFirstD  ==   null   ?   " 返回默认值NULL "  : studentFirstD.Name);


     输出结果如下：
     返回默认值null
      7）LastOrDefault 该操作符类似Last操作符，不同的是，如果没有发现任何元素返回，则返回默认值，元素为引用类型默认值为null，值类型为0
     如查询students集合中学生年龄为20的学生的最后一个，代码如下：

     

var studentLastD  =  students.Where(s  =>  s.Age  ==   20 ).FirstOrDefault();
            Console.WriteLine(studentFirstD  ==   null   ?   " 返回默认值NULL "  : studentLastD.Name);


     输出结果如下：
     返回默认值null


      8）Single 该操作符返回系列中满足某一条件的单个元素，如果满足条件不止一个元素或零个，则抛出异常
       如获取students中名字为“Li  Lei”的学生，代码如下：   

var studentSingle  =  students.Single(s  =>  s.Name.Equals( " Li Lei " ));
            Console.WriteLine(studentSingle.Name);

 
       输出结果如下：
       Li Lei


       9）SingleOrDefault 该操作符从一个系列中获取符合某一条件的唯一元素，如果没有符合元素，则返回默认值

        元素为引用类型默认值为null，值类型默认值为0.注意如果符合条件的元素有多个，会抛出异常。
       如返回students集合中SchoolId为4的学生，代码如下：

        

 var studentSingleDefault  =  students.SingleOrDefault(s  =>  s.SchoolId.Equals( 4 ));
            Console.WriteLine(studentSingleDefault  ==   null   ?   " 返回默认值null "  : studentSingleDefault.Name);


       输出结果如下：
       返回默认值null


       12、相等操作符
       1）SequenceEqual操作符可以判定两个集合是否相等,返回值为Boolean值
   

  var studentS1  =  students.Where(s  =>  s.SchoolId  ==   1 );
            var studentS2  =  students.Where(s  =>  s.SchoolId  ==   1 );
            Console.WriteLine(studentS1.SequenceEqual(studentS2));

    

        输出结果如下：
        True


        13．量词操作符
        1）All 该操作符判断系列的所有元素是否都满足某一条件，返回值为Boolean值
        如判断students集合中是否所有学生名字都以“L”开头，代码如下：

  bool  blAll  =  students.All(s  =>  s.Name.StartsWith( " L " ));
            Console.WriteLine(blAll);

        输出结果如下：
        False


        2）Any 该操作符判断集合是否至少一个元素满足某一条件，返回值为Boolean值
 

   bool  blAny  =  students.Any(s  =>  s.Name.StartsWith( " L " ));
            Console.WriteLine(blAny);

      

        输出结果如下：
        True


        3）Contains 该操作符判断系列是否包含某个特定的元素，返回值为Boolean
        如判断名称集合中是否包含“Li Lei”这个名称，代码如下：

  string  studentName  =   " Li Lei " ;
             bool  blContains  =  students.Select(s  =>  s.Name).Contains(studentName);
            Console.WriteLine(blContains);

        输出结果如下：
        True


       14、分割操作符
       1）Skip 该操作符能够掉到一定的元素到达一个指定位置，并且从该位置开始返回其余的元素
       如跳过students集合的前两个元素，读取剩下的元素，代码如下：

 var studentSkip  =  students.Skip( 2 );
             foreach  (Student student  in  studentSkip)
            {
                Console.WriteLine(student.Name);
            }

       

      输出结果如下：
       Li Ming
       Zou Qi
      Wang Long


      2）SkipWhile 该操作符基于特定的谓词略过某些符合条件的元素，返回其余的元素

      这里需要特别注意，SkipWhile对数据源进行枚举，从第一个枚举得到的元素开始，如果返回true，则跳过该元素,继续进行枚举操作。但是,如果一旦返回false，则该元素以后的所有元素,都不会再调用SkipWhile。

  int [] numSkipWhile  =   new   int [] {  5 ,  7 ,  9 ,  6 ,  9 ,  4  };
            var numSw  =  numSkipWhile.SkipWhile(n  =>  n  <   9 );
             foreach  ( int  i  in  numSw)
            {
                Console.WriteLine(i);
            }

     

      输出结果为：
       9
       6
       9
       4   


      如果数组numSkipWhile为{9,5,7,9,6,9,4}，则输出结果为：
      9
      5
      7
      9
      6
      9
      4


      3）Take 该操作符返回某个系列中连续的元素子序列，子序列开始于序列的开头，结尾为某个指定的参数，如果指定的参数超过索引，则返回到系列的结尾为止

  

  int [] numTake  =   new   int [] {  5 ,  7 ,  9 ,  6 ,  9 ,  4  };
            var numTk  =  numTake.Take( 3 );
             foreach  ( int  i  in  numTk)
            {
                Console.WriteLine(i);
            }

     输出结果为 ：
     5
     7
     9


     4） TakeWhile 该操作符通过特定的条件选取元素,如果某个元素不符合条件,则从该元素起的元素全部跳过

int [] numTaleWhile  =   new   int [] {  5 ,  7 ,  9 ,  6 ,  9 ,  4  };
            var numTw  =  numTaleWhile.TakeWhile(n  =>  n  <   9 );
             foreach  ( int  i  in  numTw)
            {
                Console.WriteLine(i);
            }

    

    输出结果为：
     5
     7

 

你可能感兴趣的:(LINQ)

  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • C# 自动化 TineAine C#代码片段自动化c#自动化模拟操作
    实现的方法可能很笨，但是确实很好用usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Runtime.InteropServices;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;/******************
  • C# Linq语句用法大全以及Lambda表达式 一个小码码 c#linq开发语言.net
    C#Linq语句用法大全以及Lambda表达式Linq：是一种用于数据查询和操作的语言集成查询（LanguageIntegratedQuery）技术。通过Linq，我们可以使用类似于SQL查询的方式来查询、筛选和操作各种类型的数据集合，包括数组、列表、集合、XML文档、数据库表等等。常见的有：LinqtoObjects：用于操作对象集合，例如数组、列表等。LinqtoXML：用于操作XML数据，支
  • C#中的LInq语句 weixin_30588907 c#数据库
    语言集成查询(LINQ)是一组技术的名称，这些技术建立在将查询功能直接集成到C#语言（以及VisualBasic和可能的任何其他.NET语言）的基础上。借助于LINQ，查询现在已是高级语言构造，就如同类、方法、事件等等。对于编写查询的开发人员来说，LINQ最明显的“语言集成”部分是查询表达式。查询表达式是使用C#3.0中引入的声明性查询语法编写的。通过使用查询语法，您甚至可以使用最少的代码对数据源
  • C#的linq语句 木生火18624 C#开发
    /查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
  • C#LINQ常用扩展语句 月落. C#c#linqsolr
    在C#中，LINQ提供了许多扩展方法，这些方法定义在System.Linq命名空间中。以下是一些常用的LINQ扩展方法：Where-过滤数据集合，返回满足条件的元素。varfilteredItems=collection.Where(item=>item.SomeProperty>10);Select-从数据集合中选择数据或创建新的投影。varprojectedItems=collection.S
  • WPF实现简单的9宫格键盘移动方块 no longer WPF学习wpf
    实现用电脑键盘上下左右实现方块的移动demoxaml文件代码：后台代码usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;usingSystem.Windows;usingSystem.Windows.Controls;usingSyste
  • .NET常见面试题汇总 .Net Core 爱好者 .netc#
    首先，汇总一共分为三部分：一是关于.NET技术的面试问题，二是关于.NET项目中的实际问题，三是历年出现过一些面试题汇总一、.NET技术面试问题请简述.NET中的装箱和拆箱。什么是泛型，以及它在.NET中的用途？请解释一下C#中的委托是什么，以及它们如何工作？什么是事件，如何使用它们？请解释一下C#中的特性(Attributes)及其应用场景。.NET中的异步编程模式有哪些？什么是LINQ，它在.
  • c# 网口通讯 图像处理进阶小白 C#
    一、命令行 客户端程序:usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;usingSystem.Net;usingSystem.Net.Sockets;usingSystem.Threading; namespaceclient{  c
  • 日志工具类-RiZhiHelp taozi_5188 asp.net常用功能和代码
    usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.IO;namespaceRiZhi{publicclassRiZhiHelp{privateconststringPath=@"E:\自己学习\RiZhi\Log\";publicstaticvoidWriteLog(s
  • LINQ 和 LINQ扩展方法 (1) 啥也学不会a C#linqc#
    LINQ函数概念：LINQ（LanguageIntegratedQuery）是一种C#语言中的查询技术，它允许我们在代码中使用类似SQL的查询语句来操作各种数据源。这些数据源可以是集合、数组、数据库、XML文档等等。LINQ提供了一种统一的编程模型，使我们能够使用相同的方式来查询和操作不同类型的数据。在C#中，LINQ主要由以下几个组成部分：数据源（Datasource）：可以是集合、数组、数据库
  • 机器视觉_联合编程(二) Zhangci］ VisionPro数码相机计算机视觉人工智能VisionPro机器视觉
    链接相机,加载tb,检测FrameGrabber链接相机拍照usingSystem;usingSystem.Collections;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usingSystem.Drawing;usingSystem.Linq;usingSystem.Text;usin
  • C#中两个问号和一个问号 andy76123
    usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;namespaceConsoleApplication1{classProgram{staticvoidMain(string[]args){int?a;a=null;//此时输出3//a=6;//此时输出6intb=a??3;Console.
  • .NET/C#⾯试题汇总系列：集合、异常、泛型、LINQ、委托、EF！ 微微的猪食小窝 c#.netlinq
    1.IList接⼝与List的区别是什么?‌定义与继承关系‌：IList是一个接口，定义了一组对象的集合，这些对象可以通过索引进行访问，并且支持插入、删除和搜索等操作。它继承自ICollection和IEnumerable，以及它们的非泛型版本。List是一个类，实现了IList接口。它提供了接口中定义的所有方法的具体实现，并添加了一些额外的功能，如排序、搜索等。‌功能与灵活性‌：使用IList接
  • 【.NET全栈】ASP.NET开发Web应用——LINQ技术 JosieBook #.NET全栈.netasp.netlinq
    文章目录一、LINQ基础1、LINQ简介2、延迟执行3、LINQ表达式简介1、基本查询语法2、投影新对象3、过滤和排序4、分组和聚合5、联合查询二、LINQtoDataSet操作内存表1、LINQtoDataSet简介2、类型化DataSet三、LINQtoSQL操作数据库1、数据实体类2、DataContext类介绍3、在ASP.NET中应用LINQtoSQL4、自动生成数据实体类5、生成存储过
  • 7个 C# 高阶用法详解：从基础到实战 一个代码猎人 ASP.NETCorec#开发语言
    C#高阶用法详解：从基础到实战在实际开发中，C#提供了很多高级特性和设计模式，帮助我们写出更加简洁、灵活和高效的代码。本篇将深入探讨C#中的高阶用法，通过丰富的示例，带你掌握这些工具的精髓。1.LINQ（LanguageIntegratedQuery）进阶用法LINQ提供了强大的查询功能，下面是一些进阶的应用场景。//示例1：结合复杂的过滤与投影varstudents=newList{newStu
  • C#中List集合使用Remove方法详解——List使用Remove方法需要注意的坑？ 猿享天开 学懂C#-高级编程技术精讲c#开发语言
    目录一、基本使用1、简单类型的例子2、复杂类型的例子二、思考三、深度解析四、正确的使用方式1、重写Equals和GetHashCode2、使用LINQ的FirstOrDefault方法五、性能考虑六、注意事项总结在C#中，List是一个常用的数据结构，它提供了一系列操作方法来管理其内部的元素。Remove方法是其中一个用于移除元素的重要方法。本文将深入探讨List.Remove方法的使用、底层原理
  • BlinqIO：业界首个生成式 AI 测试平台 blues_C AI测试：从入门到进阶人工智能AIAI测试AI测试平台
    BlinqIO：业界首个生成式AI测试平台前言简介1.注册2.生成测试自动化代码3.运行测试4.查看报告5.使用AI添加场景总结前言生成式人工智能软件测试初创公司BlinqIO打造了业界首个生成式AI测试平台，由专有的大型语言模型提供支持，采用生成式人工智能技术，并宣称该平台可以替代手工测试工程师；它能够理解软件测试的需求、可以自行创建测试自动化代码，并完全自主地维护该代码；它可以在无需任何监督的
  • 尝试自己实现Linq的Count，Where，Select方法。 李公子lm .NET技术linqc#委托泛型C#进阶
    前言今天我们来自己尝试实现一下Linq类库中的一些常用的Count，Where，Select方法。通过自己实现这些常用的基础功能，可以加深我们对委托，泛型，以及扩展方法的理解。正式开始之前呢，还是先简单说一下关于委托，泛型以及扩展方法的一些知识。基础知识委托C#中普通方法接受的是参数可以是类，可以是变量。而委托接受的是方法，可以理解为委托是可以指向方法的类型，把一个方法当做变量进行传递。C#默认提
  • WPF实现仪表盘（刻度跟随） dotNET跨平台 wpfweex3dgithubasp
    WPF开发者QQ群：340500857|微信群->进入公众号主页加入组织“前言，接着上一篇圆形进度条。”欢迎转发、分享、点赞、在看，谢谢~。01—效果预览效果预览（更多效果请下载源码体验）：02—代码如下一、DashboardControl.cs代码如下usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.
  • C# 实现傅里叶变化（DFT） 大浪淘沙胡 C#c#开发语言DFT
    1、DFT函数类usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;namespaceDFT_FFTApp.Utils{publicclassDFT{//////DFT/////////publicstaticList>DFTNative(
  • C#实现仪表盘 大浪淘沙胡 Winformc#开发语言仪表盘
    1、仪表盘控件usingSystem;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Drawing;usingSystem.Drawing.Drawing2D;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;usingSyste
  • Unity 反射绑定UI _wwzzxx unity
    ui的名称和定义的字段名要保持一致usingSystem;usingSystem.Collections;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Reflection;usingUnityEngine;usingUnityEngine.EventSystems;usingUnityEngine.UI;publiccl
  • c#——特性 Matrix Y c#linqc#
    定义特性的定义——用于在运行时传递程序中各种元素（类，方法、结构、枚举、组件等）的行为信息的声明性标签。----特性不等于注释。,net有两种类型特性——预定义特性和自定义特性创建自定义特性创建的自定义特性的命名方式——自定义特性+Attribute。该类继承于AttributeusingSystem;usingSystem.Collections.Generic;usingSystem.Linq
  • Learn OpenGL In Qt之系列简介 rainInSunny LearnOpenGLInQtqtc++3d
    竹杖芒鞋轻胜马,谁怕?一蓑烟雨任平生~个人主页：rainInSunny|个人专栏：C++那些事儿、LearnOpenGLInQt文章目录传送门写在前面为什么是OpenGL和Qt能学到什么能做点什么国漫女神炫酷进度冷酷机器人传送门待更新写在前面  本博客系列将带领读者逐步学习如何在Qt环境下使用OpenGL进行图形编程。我们将从基础知识开始，介绍OpenGL的基本概念、渲染流程和常用功能。然后，我们
  • 【C#】汉诺塔C#代码实现（递归） -凌凌漆- C#c#开发语言
    1.思路假设总共需要移动n个盘子：将A柱上的n-1个盘子借助C柱移向B柱将A柱上仅剩的最后一个盘子移向C柱将B柱上的n-1个盘子借助A柱移向C柱2.代码usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;namespaceConsoleDe
  • C# while循环与do循环 Freesial_ C#笔记c#开发语言
    学习循环语句之前，先学习跳转语句continue语句：跳出当前循环，开始一次新的循环，并没有结束循环break语句:立刻结束循环while循环语句while循环语句可以一次都不执行循环体举例:制作一个小游戏，输入两个和为100的数，积一分，否则游戏结束usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.R
  • C# 调用接口处理返回json数据 小飞鱼通达二开 .Net技术c#json
    项目中处理json需要使用Newtonsoft，访问接口使用RestSharp，先将这两个库添加项目引用，在文件头部进行引用usingNewtonsoft.Json;usingNewtonsoft.Json.Linq;usingRestSharp;方式一：按数组解析InfoModelinfo=newInfoModel();stringhostV=ins.Host;stringurlV=ins.Ur
  • C＃与其它编程语言有什么区别，以及相关优势有哪些 好好学习的不知名程序员 c#笔记
    C#编程语言的主要特性包括**面向对象、统一的类型系统、自动内存管理等**。与其它编程语言相比，C#的优势体现在**跨平台开发支持、强大的语言集成查询（LINQ）功能、高效的性能**这几个方面。C#的主要特性：1.面向对象：C#是一种完全面向对象的编程语言，支持封装、继承和多态。2.统一的类型系统：该语言拥有一个统一的类型系统，可以进行无缝的类型转换。3.自动内存管理：C#通过垃圾回收机制自动管理
  • ASP.NET使用FileUpLoad控件实现图片上传并显示 pcdd .NETasp.net
    后端代码：usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Web;usingSystem.Web.UI;usingSystem.Web.UI.WebControls;usingSystem.IO;namespaceex{publicpartialclassWebForm1:System.Web.UI.
  • 安装数据库首次应用 Array_06 javaoraclesql
    可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面 这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 注意第一次，使用SQL D
  • Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 一.修改Console密码         打开weblogic控制台，安全领域 --> myrealm -->&n
  • IllegalStateException: Cannot forward a response that is already committed Cwind javaServlets
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。 示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
  • 基于流的装饰设计模式 木zi_鸣 设计模式
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 自定义的类成为装饰类 模仿BufferedReader，对Reader进行包装，体现装饰设计模式 装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 装饰类因为增强已有对象，具备的功能该
  • Linux中的uniq命令 被触发 linux
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件 说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
  • 正则表达式Pattern 肆无忌惮_ Pattern
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。   例如，我们需要对QQ号码格式进行检验 规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
  • Oracle高级查询之OVER (PARTITION BY ..) 知了ing oraclesql
    一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
  • Python调试 矮蛋蛋 pythonpdb
    原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
    今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。 进行debug之后，发现服务器端返回的确实是有值的对象。 后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针 百合不是茶
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：   定义一个指针p来指向a的地址（&是地址符号）：        
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
  • spring aop实例annotation方法实现 bijian1013 javaspringAOPannotation
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
  • [Velocity一]Velocity语法基础入门 bit1129 velocity
    用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html   注释 1.行级注释## 2.多行注释#*  *#   变量定义 使用$开头的字符串是变量定义，例如$var1, $var2,   赋值 使用#set为变量赋值，例
  • 【Kafka十一】关于Kafka的副本管理 bit1129 kafka
    1. 关于request.required.acks   request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在   Th
  • lua统计nginx内部变量数据 ronin47 lua nginx　 统计
    server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
  • java-11.二叉树中节点的最大距离 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
  • Netty源码学习-ReadTimeoutHandler bylijinnan javanetty
    ReadTimeoutHandler的实现思路： 开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
  • jquery验证上传文件样式及大小(好用) cngolon 文件上传jquery验证
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
  • 浏览器兼容【转】 cuishikuan css浏览器IE
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 碰到频率:100% 解决方案：CSS里    *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell$#$?特殊变量
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949   特殊变量列表 变量 含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
  • android Activity间List传值 dcj3sjt126com Activity
    第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
  • tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space   ------------
  • Android 数据库事务处理 gqdy365 android
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
  • Java 打开浏览器 hw1287789687 打开网址open浏览器open browser打开url打开浏览器
    使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址 使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chromeGooglegoogle apichrome插件
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
  • 进程VS.线程 m635674608 线程
    资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 多进程模式最大
  • Linux下安装MemCached 字符串 memcached
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
  • java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 javaDAO设计模式AOP
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
    2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他