В Python самой базовой формой для нарезки является следующее:
l[start:end]
, где l
- некоторая коллекция, start
является инклюзивным индексом и end
является эксклюзивным индексом.
In [1]: l = list(range(10))
In [2]: l[:5] # first five elements
Out[2]: [0, 1, 2, 3, 4]
In [3]: l[-5:] # last five elements
Out[3]: [5, 6, 7, 8, 9]
При нарезке с начала вы можете опустить нулевой индекс, а при разрезании до конца вы можете опустить конечный индекс, поскольку он является избыточным, поэтому не нужно verbose:
In [5]: l[:3] == l[0:3]
Out[5]: True
In [6]: l[7:] == l[7:len(l)]
Out[6]: True
Отрицательные целые числа полезны при выполнении смещений относительно конца коллекции:
In [7]: l[:-1] # include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]
In [8]: l[-3:] # take the last 3 elements
Out[8]: [7, 8, 9]
Можно предоставить индексы, которые выходят за рамки, когда таких как:
In [9]: l[:20] # 20 is out of index bounds, l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [11]: l[-20:] # -20 is out of index bounds, l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Имейте в виду, что результат нарезки коллекции - это совершенно новая коллекция. Кроме того, при использовании нотации среза в назначениях длина назначения среза не обязательно должна быть одинаковой. Значения до и после назначенного среза будут сохранены, и коллекция будет сжиматься или увеличиваться, чтобы содержать новые значения:
In [16]: l[2:6] = list('abc') # assigning less elements than the ones contained in the sliced collection l[2:6]
In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]
In [18]: l[2:5] = list('hello') # assigning more elements than the ones contained in the sliced collection l [2:5]
In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]
Если вы опустите индекс начала и конца, вы сделаете копию сбор:
In [14]: l_copy = l[:]
In [15]: l == l_copy and l is not l_copy
Out[15]: True
Если начальные и конечные индексы опущены при выполнении операции присваивания, все содержимое коллекции будет заменено копией того, на что ссылаются:
In [20]: l[:] = list('hello...')
In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']
Помимо базового разреза, также можно применить следующие обозначения:
l[start:end:step]
, где l
является коллекцией, start
является инклюзивным индексом, end
является эксклюзивным index и step
- это шаг, который может использоваться для приема каждого пункта nth в l
.
In [22]: l = list(range(10))
In [23]: l[::2] # take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]
In [24]: l[1::2] # take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]
Использование step
обеспечивает полезный трюк для обратного коллекция в Python:
In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Также возможно использовать отрицательные целые числа для step
в следующем примере:
In[28]: l[::-2]
Out[28]: [9, 7, 5, 3, 1]
Однако, используя отрицательное значение для step
может стать очень запутанным. Более того, чтобы быть Pythonic, вам следует избегать использования start
, end
и step
в одном фрагменте. В случае, если это необходимо, подумайте об этом в двух назначениях (один для среза, а другой - для шага).
In [29]: l = l[::2] # this step is for striding
In [30]: l
Out[30]: [0, 2, 4, 6, 8]
In [31]: l = l[1:-1] # this step is for slicing
In [32]: l
Out[32]: [2, 4, 6]
Это хороший способ сделать это для любого двумерного массива, если вы хотите, чтобы они были в следующем порядке:
[[array [0] -elems], [array [ 1] elems] ...]
blockquote>public <T> List<T> twoDArrayToList(T[][] twoDArray) { List<T> list = new ArrayList<T>(); for (T[] array : twoDArray) { list.addAll(Arrays.asList(array)); } return list; }
Используйте java8 «flatMap», чтобы поиграть. Один из способов может быть следующим
List<Foo> collection = Arrays.stream(array).flatMap(Arrays::stream).collect(Collectors.toList());
Обратите внимание: при работе над преобразованием массивов в виде списка существует разница между примитивным массивом и массивом объектов. i.e) int [] и Integer []
, например)
int [][] twoDArray = { {1, 2, 3, 4, 40}, {5, 6, 7, 8, 50}, {9, 10, 11, 12, 60}, {13, 14, 15, 16, 70}, {17, 18, 19, 20, 80}, {21, 22, 23, 24, 90}, {25, 26, 27, 28, 100}, {29, 30, 31, 32, 110}, {33, 34, 35, 36, 120}}; List list = new ArrayList(); for (int[] array : twoDArray) { //This will add int[] object into the list, and not the int values. list.add(Arrays.asList(array)); }
и
Integer[][] twoDArray = { {1, 2, 3, 4, 40}, {5, 6, 7, 8, 50}, {9, 10, 11, 12, 60}, {13, 14, 15, 16, 70}, {17, 18, 19, 20, 80}, {21, 22, 23, 24, 90}, {25, 26, 27, 28, 100}, {29, 30, 31, 32, 110}, {33, 34, 35, 36, 120}}; List list = new ArrayList(); for (Integer[] array : twoDArray) { //This will add int values into the new list // and that list will added to the main list list.add(Arrays.asList(array)); }
Чтобы работать с ответом Keppil; вам нужно преобразовать свой примитивный массив в массив объектов с помощью . Как преобразовать int [] в Integer [] в Java?
Else добавить значения int один за другим в нормальном для loop.
int iLength = twoDArray.length; List<List<Integer>> listOfLists = new ArrayList<>(iLength); for (int i = 0; i < iLength; ++i) { int jLength = twoDArray[0].length; listOfLists.add(new ArrayList(jLength)); for (int j = 0; j < jLength; ++j) { listOfLists.get(i).add(twoDArray[i][j]); } }
Также обратите внимание, что массив Arrays.asList (массив) даст список фиксированного размера; поэтому размер не может быть изменен .
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
yourList.add(foosArray[i][j]);
Я думаю, что другие трюки не нужны, потому что, во всяком случае, они будут использовать это решение.
Поскольку java-8
List<Foo> collection = Arrays.stream(array) //'array' is two-dimensional
.flatMap(Arrays::stream)
.collect(Collectors.toList());
ArrayList<Elelement[]> allElelementList = new ArrayList<>(allElelements.length);
allElelementList.addAll(Arrays.asList(allElelements));
allElelements является двумерным
другой метод.
//converting 2D array to string
String temp = Arrays.deepToString(fooArr).replaceAll("\\[", "").replaceAll("\\]", "");
List<String> fooList = new ArrayList<>(Arrays.asList(","));
Это можно сделать с помощью Java 8 stream API следующим образом:
String[][] dataSet = new String[][] {{...}, {...}, ...};
List<List<String> list = Arrays.stream(dataSet)
.map(Arrays::asList)
.collect(Collectors.toList());
В принципе, вы делаете три вещи:
Единственный способ превратить его в список - перебирать массив и строить список по ходу, например:
ArrayList<Foo[]> list = new ArrayList<Foo[]>(foosArray.length);
for(Foo[] foo: foosArray){
list.add(foo);
}