标签: take

如何获取List(使用LINQ)并将其分解为每隔8个条目分区原始列表的列表列表？

我想像这样的东西会涉及Skip和/或Take,但我仍然是LINQ的新手.

编辑:使用C#/ .Net 3.5

编辑2:这个问题的措辞不同于其他"重复"问题.虽然问题是相似的,但这个问题的答案是优越的:"接受"的答案都非常可靠(包括yield声明)以及Jon Skeet建议使用MoreLinq(在"其他"问题中不推荐使用).有时复制是好的,因为它们迫使重新检查问题.

据我所知,RxJava2 values.take(1)创建了另一个Observable,它只包含原始Observable中的一个元素.哪个不能抛出异常,因为它被take(1)第二次发生的效果过滤掉了.

如下面的代码片段所示

    Observable<Integer> values = Observable.create(o -> {
        o.onNext(1);
        o.onError(new Exception("Oops"));
    });

    values.take(1)
            .subscribe(
                    System.out::println,
                    e -> System.out.println("Error: " + e.getMessage()),
                    () -> System.out.println("Completed")
            );

产量

1
Completed
io.reactivex.exceptions.UndeliverableException: java.lang.Exception: Oops
    at io.reactivex.plugins.RxJavaPlugins.onError(RxJavaPlugins.java:366)
    at io.reactivex.internal.operators.observable.ObservableCreate$CreateEmitter.onError(ObservableCreate.java:83)
    at ch02.lambda$main$0(ch02.java:28)
    at io.reactivex.internal.operators.observable.ObservableCreate.subscribeActual(ObservableCreate.java:40)
    at io.reactivex.Observable.subscribe(Observable.java:10841)
    at io.reactivex.internal.operators.observable.ObservableTake.subscribeActual(ObservableTake.java:30)
    at io.reactivex.Observable.subscribe(Observable.java:10841)
    at io.reactivex.Observable.subscribe(Observable.java:10827)
    at io.reactivex.Observable.subscribe(Observable.java:10787)
    at ch02.main(ch02.java:32)
Caused by: java.lang.Exception: Oops
    ... 8 more
Exception in thread "main" io.reactivex.exceptions.UndeliverableException: java.lang.Exception: Oops
    at io.reactivex.plugins.RxJavaPlugins.onError(RxJavaPlugins.java:366)
    at io.reactivex.internal.operators.observable.ObservableCreate$CreateEmitter.onError(ObservableCreate.java:83)
    at ch02.lambda$main$0(ch02.java:28)
    at …

LINQ to Objects支持对字符串对象的查询,但是当我使用如下代码时:

string SomeText = "this is some text in a string";
return SomeText.Take(6).ToString();

我得到的只是:

System.Linq.Enumerable+<TakeIterator>d__3a`1[System.Char]

在这个问题中,这被视为"意外",但这正是我实际上要做的事情,我无法通过任何地方的搜索找到它.

我知道还有其他方法可以操作字符串,但后来我也知道你可以用LINQ做一些非常酷的技巧,我想知道是否有办法用LINQ修剪字符串到一定的长度？

是否可以IQueryable<MyObject> = query.Take(1)在LINQ查询语法中编写或等效.我正在使用C#5和EF 5.

从C#中的Enumerable中获取精确x值的最佳方法是什么？如果我像这样使用Enumerable .Take():

var myList = Enumerable.Range(0,10);
var result = myList.Take(20);

结果只有10个元素.

我想用默认值填充缺少的条目.像这样的东西:

var myList = Enumerable.Range(0,10);
var result = myList.TakeOrDefault(20, default(int));  //Is there anything like this?

在C#中是否有这样的功能,如果没有,那么实现这一目标的最佳方法是什么？

我使用下面的代码从中获取一些项目IEnumerable,但它始终将源返回为null并计为0并且实际上存在项目IEnumerable

private void GetItemsPrice(IEnumerable<Item> items, int customerNumber)
{
    var a = items.Skip(2).Take(5);
}

当我尝试访问a它时,它有数量0.这里出了什么问题？

我正在使用Spark 1.5.

我有一个30列的列,我integers从数据库加载:

val numsRDD = sqlContext
     .table(constants.SOURCE_DB + "." + IDS)
     .select("id")
     .distinct
     .map(row=>row.getInt(0))

这是输出numsRDD:

numsRDD.collect.foreach(println(_))

643761
30673603
30736590
30773400
30832624
31104189
31598495
31723487
32776244
32801792
32879386
32981901
33469224
34213505
34709608
37136455
37260344
37471301
37573190
37578690
37582274
37600896
37608984
37616677
37618105
37644500
37647770
37648497
37720353
37741608

接下来,我想为那些产生3的所有组合,ids然后将每个组合保存为表单的元组:< tripletID: String, triplet: Array(Int)>并将其转换为数据帧,我按如下方式执行:

// |combinationsDF| = 4060 combinations
val combinationsDF = sc
  .parallelize(numsRDD
     .collect
     .combinations(3)
     .toArray
     .map(row => …

这是我的take版本使用foldr:

myTake n list = foldr step [] list
                where step x y | (length y) < n = x : y
                               | otherwise = y

main = do print $ myTake 2 [1,2,3,4]

输出不是我所期望的:

[3,4]

然后我尝试通过插入y自身的长度进行调试,结果是:

[3,2,1,0]

我不明白为什么长度按降序插入.也许我错过了一些明显的事

我正在学习火花.我试图演示一个简单的聚类算法.假设我在我的rdd上找到了代表集群的k项.问题是当我尝试将它们带到驱动程序时,我得到一个警告说"块锁没有被tid释放".这也导致性能不佳... 20下面代码的迭代在4核上使用2mb数据集需要11秒.这比我的串行版本更糟糕.好的是我仍然得到了正确的结果.请看一下:

首先,我拿一个项目.任何项目都可以

List<Tuple2<Long, Instance>> selectedTuple = dataset.take(1);
        Instance selected = selectedTuple.get(0)._2;

然后我创建一个对象,它将根据我刚找到的选定项找到我的集群的候选项.为了记录,它实现了PairFlatMapFunction

        NCPComparator comp = new NCPComparator(meta, selected);

下一步找到一些候选人

        JavaPairRDD<Long, Double> candidates = this.dataset.mapPartitionsToPair(comp);

但是现在,我需要具有最低Double值的k one,所以我实现了一个TupleComparator.然后我调用了takeOrdered

        List<Tuple2<Long, Double>> groupList = candidates.takeOrdered(k, new TupleComparator());

此时,出现该警告.调用top()也是如此.并且作为迭代算法,它出现在每次迭代中.我没有向您展示其余的代码.你猜对了..它不仅仅是微不足道的:-)

而且,我在我的rdds上做了适当的坚持.乔布斯似乎像一个魅力.我发现很多人都有这个问题,但没有答案.

我希望我给你足够的细节,这是我的第一篇文章!

假设我的数据库中有一个包含1.000.000记录的表.

如果我执行:

SELECT * FROM [Table] LIMIT 1000

这个查询会花费同样的时间,好像我有那个包含1000记录的表,只是这样做:

SELECT * FROM [Table]

？

我不是在寻找是否需要完全相同的时间.我只是想知道第一个是否比第二个花费更多的时间来执行.

我说1.000.000记录,但它可能20.000.000.那只是一个例子.

编辑:
当然,当使用LIMIT并且不在同一个表中使用它时,使用LIMIT构建的查询应该更快地执行,但我不是要求...

使其通用:

Table1:X记录
Table2:Y记录

(X << Y)

我想要比较的是:

SELECT * FROM Table1

和

SELECT * FROM Table2 LIMIT X

编辑2:
这就是我问这个问题的原因:

我有一个数据库,有5个表和一些表之间的关系.其中一个表(我100%肯定)包含大约5.000.000记录.我使用SQL Server CE 3.5,Entity Framework作为ORM和LINQ to SQL来进行查询.

我需要基本上执行三种非简单查询,而我正在考虑向用户显示记录限制(就像很多网站一样).如果用户想要查看更多记录,则他/她具有的选项是限制更多搜索.

所以,问题出现了,因为我正在考虑这样做(限制X每个查询的记录)或者如果只在数据库中存储X结果(最近的那些),这将需要在数据库中做一些删除,但我只是在想...

因此,该表可能包含5.000.000更多记录,而我不想要的是显示用户1000左右,即使是这样,查询仍然会像返回5.000.000行一样慢.