精华内容
下载资源
问答
  • java8-怎么用lambda拼接字符串

    千次阅读 2020-05-11 14:59:39
    怎么lambda拼接字符串 String result = list.stream().collect(Collectors.joining("")); joining方法中,比如你用 ,连接就写 String result = list.stream().collect(Collectors.joining(","));

    怎么lambda拼接字符串

    String result = list.stream().collect(Collectors.joining(""));
    

    joining方法中,比如你用 ,连接就写

    String result = list.stream().collect(Collectors.joining(","));
    
    展开全文
  • java8 如何使用lambda拼接字符串?

    千次阅读 2018-04-03 23:37:21
    https://segmentfault.com/q/1010000005054853String result = list.stream().collect(Collectors.joining(""));

    https://segmentfault.com/q/1010000005054853


    String result = list.stream().collect(Collectors.joining(""));

    展开全文
  • 主要介绍了Java lambda list转换map时,把多个参数拼接作为key操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • EntityFramework动态组合Lambda表达式作为数据筛选条件,代替拼接SQL语句 ...Entity Framework动态Lambda条件Linq拼接Lambda拼接代替sql拼接 传统的操作数据库方式,筛选数据需要用Strin...

    EntityFramework动态组合Lambda表达式作为数据筛选条件,代替拼接SQL语句

    分类: C# Lambda/Linq Entity Framework 491人阅读 评论(0) 收藏 举报

    传统的操作数据库方式,筛选数据需要用StringBuilder拼接一大堆的WHERE子句。

    在Entity Framework中,代码稍有不慎就会造成巨大性能消耗,如:

    using(var db=new MyDbContext())

    {

    var s= db.Students.ToList().First(s=>s.ID=1200);

    }

    嘣!进行了全表数据读取!当然一般人也不会犯这种低级的错误,言归正传。

    可以简单的这样筛选数据:

     

    using(var db=new MyDbContext())

    {

    var list =db.Students.AsQueryable();

    if(********){list=list.Where(s=>s.ID=1200);}

    if(******){list=list.Where(...)}

    }

    但是有时这种方法不能完成特定需求,如:

     

    using(var db=new MyDbContext())

    {

    var list =db.Students.AsQueryable();

    if(条件1){list=list.Where(s=>s.ID>1200);}

    if(条件2){list=list.Where(s=>s.ID<1000);}

    }

    现在条件1和条件2同时成立,得到的是空结果集而不是ID>1200和ID<1000的结果集。

    这只是两个并列简单条件的组合,如果是条件嵌套呢?

    下面是假想:

    using (var db = new MyDbContext())
                {


                    Expression<Func<Student, bool>> checkStudent1 = s1 => s1.ID > 1200;
                    Expression<Func<Student, bool>> checkStudent2 = s2 => s2.ID < 1000;
                    var e =
                        Expression.Lambda<Func<Student, bool>>(
                            Expression.Or(checkStudent1.Body, checkStudent2.Body), checkStudent1.Parameters);
                    var result = db.Students.Where(e).ToList();
                }

    叫它假想的原因是执行会产生异常”The parameter 's2' was not bound in the specified LINQ to Entities query expression“。

    e的内容是{s1 => ((s1.ID > 1200) Or (s2.ID < 1000))},很明显s2这个参数是没有被定义的。

    实际上我们一直操作一个Student表,最终我们想要的也是多Lambda表达式合在一起对该Student表的操作。换句话说,s2应该用s1代替。

    有人说了,这样:

    Expression<Func<Student, bool>> checkStudent1 = s => s.ID > 1200;
                    Expression<Func<Student, bool>> checkStudent2 = s => s.ID < 1000;
                    var e =
                        Expression.Lambda<Func<Student, bool>>(
                            Expression.Or(checkStudent1.Body, checkStudent2.Body), checkStudent1.Parameters);
                    var result = db.Students.Where(e).ToList();

    异常:”The parameter 's' was not bound in the specified LINQ to Entities query expression“。

    e的内容是{s => ((s.ID > 1200) Or (s.ID < 1000))},现在参数都一样是s了,但其实它们的GUID不同,也就是说它们还是两个不同的参数。

    我们需要做的是手工把checkStudent2.Body里面的参数s换成checkStudent1.Body里面的参数s。

    ExpressionVisitor可以很好的完成这步操作。拿个别人现成的例子来用:

     

    [csharp] view plain copy print ?
    1. public class ParameterRebinder : ExpressionVisitor  
    2.     {  
    3.         private readonly Dictionary<ParameterExpression, ParameterExpression> map;  
    4.   
    5.         public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)  
    6.         {  
    7.             this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();  
    8.         }  
    9.   
    10.         public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)  
    11.         {  
    12.             return new ParameterRebinder(map).Visit(exp);  
    13.         }  
    14.   
    15.         protected override Expression VisitParameter(ParameterExpression p)  
    16.         {  
    17.             ParameterExpression replacement;  
    18.             if (map.TryGetValue(p, out replacement))  
    19.             {  
    20.                 p = replacement;  
    21.             }  
    22.             return base.VisitParameter(p);  
    23.         }  
    24.     }  
    public class ParameterRebinder : ExpressionVisitor
        {
            private readonly Dictionary<ParameterExpression, ParameterExpression> map;
    
            public ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
            {
                this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
            }
    
            public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
            {
                return new ParameterRebinder(map).Visit(exp);
            }
    
            protected override Expression VisitParameter(ParameterExpression p)
            {
                ParameterExpression replacement;
                if (map.TryGetValue(p, out replacement))
                {
                    p = replacement;
                }
                return base.VisitParameter(p);
            }
        }


     

    更改后的测试代码:

    Expression<Func<Student, bool>> checkStudent1 = s => s.ID > 1200;
                    Expression<Func<Student, bool>> checkStudent2 = s => s.ID < 1000;
                    
                    var body2 =
                        ParameterRebinder.ReplaceParameters(
                            checkStudent2.Parameters.Select((s,i)=>new{s,f=checkStudent1.Parameters[i]}).ToDictionary(p=>p.s,p=>p.f), checkStudent2.Body);
                    var e =
                        Expression.Lambda<Func<Student, bool>>(
                            Expression.Or(checkStudent1.Body, body2), checkStudent1.Parameters);
                    var result = db.Students.Where(e).ToList();

    至此表达式顺利拼接完成。当然这样使用还是麻烦,借用别人的扩展类稍微修改一下:

     

    [csharp] view plain copy print ?
    1. public static class PredicateBuilder  
    2. {  
    3.   
    4.     public static Expression<Func<T, bool>> True<T>() { return f => true; }  
    5.     public static Expression<Func<T, bool>> False<T>() { return f => false; }  
    6.     public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)  
    7.     {  
    8.         // build parameter map (from parameters of second to parameters of first)   
    9.         var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);  
    10.   
    11.         // replace parameters in the second lambda expression with parameters from the first   
    12.         var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);  
    13.   
    14.         // apply composition of lambda expression bodies to parameters from the first expression    
    15.         return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);  
    16.     }  
    17.   
    18.     public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)  
    19.     {  
    20.         return first.Compose(second, Expression.And);  
    21.     }  
    22.   
    23.     public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)  
    24.     {  
    25.         return first.Compose(second, Expression.Or);  
    26.     }  
    27. }  
        public static class PredicateBuilder
        {
    
            public static Expression<Func<T, bool>> True<T>() { return f => true; }
            public static Expression<Func<T, bool>> False<T>() { return f => false; }
            public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
            {
                // build parameter map (from parameters of second to parameters of first)
                var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);
    
                // replace parameters in the second lambda expression with parameters from the first
                var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
    
                // apply composition of lambda expression bodies to parameters from the first expression 
                return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
            }
    
            public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return first.Compose(second, Expression.And);
            }
    
            public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return first.Compose(second, Expression.Or);
            }
        }

     

     

     

    参考: http://blogs.msdn.com/b/meek/archive/2008/05/02/linq-to-entities-combining-predicates.aspx
    完美的动态拼接Lambda表达式如下:

    using (var db = new MyDbContext())
                {
                    var predicate = PredicateBuilder.True<Student>();
                    predicate=predicate.And(s => s.ID > 1200);
                    predicate=predicate.Or(s => s.ID < 1000);
                    var result = db.Students.Where(predicate).ToList();
                }

    下面是一个我自己使用的例子,仅供参考:

     

    [csharp] view plain copy print ?
    1. using (var db = new SHTrackerDbContext())  
    2.             {  
    3.   
    4.                 var predicate = PredicateBuilder.True<Course>();  
    5.                 settings = DecorateSettings(settings);  
    6.   
    7.                 Expression<Func<Course, bool>> checkCourse = c => db.Students.Any(s => s.CourseID == c.ID);  
    8.                 if (!string.IsNullOrEmpty(settings.Quater_Year))  
    9.                 {  
    10.   
    11.                     checkCourse =  
    12.                         c => db.Students.Any(s => s.CourseID == c.ID && db.Student2CBOs.Any(  
    13.                             s2c => s2c.StudentID == s.ID && s2c.Quater_Year.Equals(settings.Quater_Year)));  
    14.                 }  
    15.                 if (settings.QuaterYearArray != null)  
    16.                 {  
    17.                     checkCourse =  
    18.                         c => db.Students.Any(s => s.CourseID == c.ID && db.Student2CBOs.Any(  
    19.                             s2c =>  
    20.                             s2c.StudentID == s.ID && settings.QuaterYearArray.Any(qy => qy.Equals(s2c.Quater_Year))));  
    21.                 }  
    22.   
    23.                 if (!string.IsNullOrEmpty(settings.DPU_ID))  
    24.                 {  
    25.                     checkCourse =  
    26.                         checkCourse.And(  
    27.                             c => db.Students.Any(s => s.CourseID == c.ID && s.DPU_ID.Equals(settings.DPU_ID)));  
    28.                 }  
    29.                 predicate = predicate.And(checkCourse);  
    30.   
    31.                 if (settings.IsCheckInstructorName)  
    32.                 {  
    33.                     predicate = predicate.And(c => c.InstructorName.Equals(settings.InstructorName));  
    34.                 }  
    35.                 if (!string.IsNullOrEmpty(settings.Term))  
    36.                 {  
    37.                     predicate = predicate.And(c => c.TermDescription.Equals(settings.Term));  
    38.                 }  
    39.                 if (settings.TermArray != null)  
    40.                 {  
    41.                     predicate = predicate.And(c => settings.TermArray.Any(t => t.Equals(c.TermDescription)));  
    42.                 }  
    43.                 if (settings.CourseType != CourseType.All)  
    44.                 {  
    45.                     predicate = predicate.And(c => c.Type == (int) settings.CourseType);  
    46.                 }  
    47.                 var cc =  
    48.                     new CourseCollection(  
    49.                         db.Courses.AsNoTracking()  
    50.                           .Where(predicate)  
    51.                           .OrderByDescending(m => m.ID)  
    52.                           .Skip((pageIndex - 1)*pageSize)  
    53.                           .Take(pageSize)  
    54.                           .ToList(),  
    55.                         db.Courses.AsNoTracking().Where(predicate).Count())  
    56.                         {  
    57.                             PageIndex = pageIndex,  
    58.                             PageSize = pageSize,  
    59.                             Settings = DecorateSettings(settings)  
    60.                         };  
    61.   
    62.                 return cc;  
    63.             }  

    参考网址http://blogs.msdn.com/b/meek/archive/2008/05/02/linq-to-entities-combining-predicates.aspx

    转载于:https://www.cnblogs.com/CielWater/p/3399949.html

    展开全文
  • /// 测试 Lambda 拼接表达式 /// </summary> /// <param name="request"></param> /// <returns></returns> // POST api/values [HttpPost] public ListPageResponse<...

          /// <summary>
            /// 测试 Lambda 拼接表达式
            /// </summary>
            /// <param name="request"></param>
            /// <returns></returns>
            // POST api/values
            [HttpPost]
            public ListPageResponse<Base_VersionControl> Post([FromBody]SelectVersionControlRequest request)
            {
                ListPageResponse<Base_VersionControl> response = new ListPageResponse<Base_VersionControl>();
                int Total = 0;
                //排序
                Expression<Func<Base_VersionControl, int>> order = ex => ex.ID;
                var orderlist = PageQueryService.LoadPageItem(request, request.PageSize, request.CurrentPage, out Total, true, order);
                response.Datas = orderlist;
                response.Total = Total;
                return response;
            }

         /// <summary>
            /// 获取where ambda  
            /// </summary>
            /// <typeparam name="TRequest"></typeparam>
            /// <typeparam name="T"></typeparam>
            /// <param name="request"></param>
            /// <returns></returns>
            public static Expression<Func<T, bool>> GetLambdaByRequest<TRequest, T>(TRequest request) where T : class
            {

                Expression<Func<T, bool>> where = ex => true;
                foreach (PropertyInfo info in typeof(TRequest).GetProperties())
                {
                    object value = info.GetValue(request, null);
                    if (info.Name != "CurrentPage" && info.Name != "PageSize" && value != null && value.ToString() != "")
                    {

                        if (info.Name == "Title")
                        {
                            where = where.And(LambdaUtil<T>.In(info.Name, value.ToString().Split(",")));
                        }
                        else
                        {
                            where = where.And(LambdaUtil<T>.Equal(info.Name, info.GetValue(request, null)));
                        }
                    }
                }
                return where;
            }

            /// <summary>
            ///    分页查询
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <typeparam name="TKey"></typeparam>
            /// <param name="pageSize">每页多少行</param>
            /// <param name="pageIndex">第几页</param>
            /// <param name="total"></param>
            /// /// <param name="whereLambda">条件 lambda表达式</param>
            /// <param name="orderByLambda">排序 lambda表达式</param>
            /// /// <param name="isAsc">是否升序</param>
            /// <returns></returns>

            public static List<T> LoadPageItem<T, TRequest, TKey>(TRequest request, int pageSize, int pageIndex, out int total, bool isAsc, Expression<Func<T, TKey>> orderbyLambda) where T : class
            {
                SqlserverModel sqlserver = new SqlserverModel();
                Expression<Func<T, bool>> whereLambda = GetLambdaByRequest<TRequest, T>(request);
                total = sqlserver.Set<T>().Where(whereLambda).Count();
                //倒序或升序
                if (isAsc)
                {
                    var temp = sqlserver.Set<T>().Where(whereLambda)
                                 .OrderBy<T, TKey>(orderbyLambda)
                                 .Skip(pageSize * (pageIndex - 1))
                                 .Take(pageSize);
                    return temp.AsQueryable().ToList();
                }
                else
                {
                    var temp = sqlserver.Set<T>().Where(whereLambda)
                               .OrderByDescending<T, TKey>(orderbyLambda)
                               .Skip(pageSize * (pageIndex - 1))
                               .Take(pageSize);
                    return temp.AsQueryable().ToList();
                }
            }

    展开全文
  • lambda 表达式拼接

    千次阅读 2017-03-30 16:11:16
    lambda 表达式拼接扩展方法
  • 主要介绍了C#中方法的直接调用、反射调用与Lambda表达式调用对比,本文着重讲解了方法的三种调用方法以及它们的性能对比,需要的朋友可以参考下
  • 下面是代码,其实主要就是用Expression生成指定的lambda, 算是抛砖引玉吧 /// <summary> /// 多条件查询 /// </summary> /// <typeparam name="TEntity">映射实体</typeparam> ...
  • c# 动态拼接lambda表达式

    千次阅读 2018-11-21 11:28:22
    /// Lambda表达式拼接扩展类 /// &lt;/summary&gt; /// https://blogs.msdn.microsoft.com/meek/2008/05/02/linq-to-entities-combining-predicates/ /// http://www.albahari.co...
  • lambda表达式拼接字符串

    千次阅读 2017-10-25 18:18:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • Java 使用 Lambda 表达式拼接 字符串

    千次阅读 2018-04-13 10:15:43
    List<ProductInfoVO> list = dao .queryDocesByCondition (condition) ; String value = list .stream () .map (productInfoVO -> String .valueOf (productInfoVO ...拼接的符号使用的是 “,”
  • 本文代码转自这篇文章,先做下记录。 public static class LambdaUtil<T> { /// <summary>... /// lambda表达式:t=>true /// </summary> /// <returns></return...
  • Lambda 表达式查询条件拼接 调用实例 var predicate = PredicateBuilder.True(); if (!string.IsNullOrWhiteSpace(select.so_text)) { predicate = predicate.And(d => d.price > 10); predicate = ...
  • 学习要点: * 1.如何利用Lambda 跟泛型方法配合的区别 .(非委托) * 2.利用Lambda 反射调用属性值 .
  • lambda 字符串拼接

    2021-04-17 20:12:29
    String str = result().map(o -> o.getId() + "-" + o.getName()).collect(Collectors.joining(","));
  • Lamda表达式的拼接合并类 /// <summary>... /// Lambda表达式拼接扩展类 /// </summary> public static class ExpressionHelp { /// <summary> /// Lambda表达式拼接 /// &l...
  • JAVA jdk1.8 Lamber获取集合中元素的某个属性 指定 分隔符 拼接字符串依赖JDK1.8 Lamber使用Lamber表达式效果:当然返回类型为 List依赖JDK1.8 Lamber 我们在开发过程中经常遇到 一对多的关系,而有时候展示时需要将...
  • Map<String, Parts> partsMap = synList.stream().collect(Collectors.toMap(k -> k.getOe()+k.getOeId()+k.getPartGroupId()+k.getStdPartId()+k.getBrandCode(), part -> part));
  • 集合元素拼接-lambda

    2020-12-24 15:27:26
    文章目录普通方法String.join()lambda表达式 这次学到了一个集合元素拼接的好方法 要求: 集合中有【“12”,“23”,“45”】 拼接成字符串:12,23,45 普通方法 通过for循环集合遍历,这个方法比较麻烦,需要判断...
  • 现需求调整,要求一个人员只显示一条数据,多个区域用逗号分隔,lambda写法如下: //分组,把相同人员区域以逗号分隔,一个人员显示一条数据 query = query.GroupBy(m => m.UserId) .Select(m => new ...
  • 最近在做数据迁移的时候有遇到做导航对应时,需要动态拼接OR查询条件的情况,因为平常也比较少用到Lambda表达式查询数据,花费了不少的时间,现将解决方案记录如下: if (!strCls.IsNullOrEmptyOrWhiteSpace()) { ...
  • 拼接 字符串 String value = memberRankList.stream().map(MemberRanking -> MemberRanking.getRowIndex().toString()).collect(Collectors.joining(",")); 多字段排序 list.sort(Comparator.comparing(test5::...
  • Lambda 动态表达式(排序)

    千次阅读 2018-05-31 11:32:13
    var orderByExpression = Expression.Lambda(propertyAccess, parameter); var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType }, source.Expression...
  • java 8 lambda工厂模式 抽象工厂模式提供了一种封装一组具有共同主题的单个工厂而无需指定其具体类的方法。 在正常使用中,将创建抽象工厂的具体实现,然后使用工厂的通用接口来创建具体对象。 Java领域(抽象的...
  • 传统的操作数据库方式,筛选数据需要用StringBuilder拼接一大堆的WHERE子句。 在Entity Framework中,代码稍有不慎就会造成巨大性能消耗,如: using(var db=new MyDbContext()) { var s=db.Students.ToList()....
  • C#中合并两个lambda表达式

    千次阅读 2019-06-14 18:00:27
    在LINQ中如何查询条件不固定,如何合并两个lambda表达式?其中一个方式是LINQ.Dynamic,关于LINQ.Dynamic的简单使用可以参考这篇文章,还有一种方法是利用Expression表达式树,有关表达式树的介绍,可以看这篇文章。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,498
精华内容 8,599
关键字:

lambda拼接