我有一个List<String>,我需要从这个列表中取一个子列表.在.NET 3.5中是否有可用于此的列表方法？
所以我一直在玩python并注意到一些看起来有些奇怪的东西.-1从列表中选择的语义似乎不一致.
所以我有一个数字列表
ls = range(1000)
当然,列表的最后一个元素,ls[-1]但如果我采用一个子列表,以便从中点到最后得到所有内容我会做
ls[500:-1]
但这并没有给我一个包含列表中最后一个元素的列表,而是一个包含UP到最后一个元素的列表.但是,如果我这样做
ls[0:10]
我得到一个包含第十个元素的列表(因此选择器应该包含在内),为什么它不起作用-1.
我当然可以做ls[500:]或ls[500:len(ls)](这将是愚蠢的).我只是想知道-1的交易是什么,我意识到我不需要它.
我使用ArrayList并尝试将其一部分复制到另一个ArrayList,因此我使用:
sibling.keys = (ArrayList<Integer>) keys.subList(mid, this.num);
其中"sibling.keys"是新的ArrayList,"keys或this.keys"是旧的ArrayList.我使用了铸造,因为eclipse告诉我这样做但是它抛出了ClassCastException:
java.util.ArrayList $ SubList无法强制转换为java.util.ArrayList
有什么建议？
我在Java中有这个奇怪的(我认为)问题.我有一个ArrayList,我想要一个子列表.但我得到了以下例外.
package javatest;
import java.util.ArrayList;
public class JavaTest {
public static void main(String[] args) {
ArrayList<Integer> alist = new ArrayList<Integer>();
alist.add(10);
alist.add(20);
alist.add(30);
alist.add(40);
alist.add(50);
alist.add(60);
alist.add(70);
alist.add(80);
ArrayList<Integer> sub = (ArrayList<Integer>) alist.subList(2, 4);
for (Integer i : sub)
System.out.println(i);
}
}
run:线程"main"中的异常java.lang.ClassCastException:java.util.RandomAccessSubList无法强制转换为javatest.JavaTest.main中的java.util.ArrayList(JavaTest.java:17)Java结果:1
获取子列表的正确方法是什么？
谢谢
是否有一个.NET相当于Java的的List.subList(),工程上IList<T>？
如果我有一个清单,请说
lst = ['hello', 'foo', 'test', 'world', 'bar', 'idk']
我想将它拆分为一个子列表,'foo'并将其'bar'作为开始和结束关键字,以便我得到
lst = ['hello', ['foo', 'test', 'world', 'bar'], 'idk']
我目前这样做的方式如下.
def findLoop(t):
inds = [index for index, item in enumerate(t) if item in ["FOO", "BAR"]]
centre = inds[(len(inds)/2)-1:(len(inds)/2)+1]
newCentre = t[centre[0]:centre[1]+1]
return t[:centre[0]] + [newCentre] + t[centre[1]+1:]
def getLoops(t):
inds = len([index for index, item in enumerate(t) if item in ["FOO", "BAR"]])
for i in range(inds):
t = findLoop(t)
return t
这看起来有点混乱,但它对于嵌套的开始/结束关键字非常有效,因此子列表可以在子列表中形成,但它不适用于多个开始/结束关键字不在彼此内部.嵌套并不重要,所以任何帮助都将受到赞赏.
是否有一个技巧或前奏函数来测试列表是否包含特定的子字符串/子列表？
xyz :: [a] -> [a] -> Bool
xyz "hello world" "worl" -> True
xyz [1,2,3,4,5,6,7,8,1,2,3,4,5] [7,8,1] -> True
我试着自己写一个,但这是一个微不足道的问题,我不想重新发明轮子.
例如,我有一个可变大小的列表
[1, 2, 3, 4]
我想尽可能地将这个列表分成两部分:
([], [1, 2, 3, 4])
([1], [2, 3, 4])
([2], [1, 3, 4])
([3], [1, 2, 4])
([4], [1, 2, 3])
([1, 2], [3, 4])
([1, 3], [2, 4])
([1, 4], [2, 3])
([2, 3], [1, 4])
([2, 4], [1, 3])
([3, 4], [1, 2])
([1, 2, 3], [4])
([1, 2, 4], [3])
([1, 3, 4], [2])
([2, 3, 4], [1])
([1, 2, 3, 4], [])
我很确定这不是一个未知的问题,可能有一个算法,但我找不到一个.此外,这不应该使用任何外部库,而是使用大多数语言中的简单语言功能(循环,条件,方法/函数,变量......).
我在Python中编写了一个hackish解决方案:
def get_all(objects):
for i in range(1, …我知道如何将列表拆分成偶数组,但我无法将其拆分为不均匀的组.
基本上这就是我所拥有的:一些列表,我们称之为mylist包含x元素的列表.
我还有另一个文件,我们称之为second_list,看起来像这样:
{2, 4, 5, 9, etc.}
现在我想做的是mylist通过second_list中的间距划分为不均匀的组.所以,我希望我的第一组成为前两个元素mylist,第二组成为接下来的4个元素mylist,第三组成为接下来的5个元素mylist,第四组成为下一个9元素的"mylist",等等.
有一些简单的方法来做到这一点？如果你想将它分成偶数组,我尝试做类似的事情:
for j in range(0, len(second_list)):
for i in range(0, len(mylist), second_list[j]):
chunk_mylist = mylist[i:i+second_list[j]]
然而,这不会像我想要的那样分裂它.我想用我的#子列表是的,结束了len(second_list),也正常分裂,这给比这更大量的(也是分裂不正确地).
我有以下列表:
['|', u'MOM', u'DAD', '|', u'GRAND', '|', u'MOM', u'MAX', u'JULES', '|']
并希望它被"|"拆分 所以结果看起来像:
[[u'MOM', u'DAD'],[ u'GRAND'], [u'MOM', u'MAX', u'JULES']]
我怎样才能做到这一点？我只在网上找到需要一定长度元素的子列表示例