arraylist常用方法

Ⅰ Array與List的優缺點

Array與List,使指數據結構概念上的數組與鏈表的優缺點吧.
如果指的是Array類(或介面)與List介面的優缺點的話,就不好理解了.

數組,在內存上給出了連續的空間.鏈表,內存地址上可以是不連續的,每個鏈表的節點包括原來的內存和下一個節點的信息(單向的一個,雙向鏈表的話,會有兩個).

數組優於鏈表的:
1.內存空間佔用的少,因為鏈表節點會附加上一塊或兩塊下一個節點的信息.但是數組在建立時就固定了.所以也有可能會因為建立的數組過大或不足引起內存上的問題.
2.數組內的數據可隨機訪問.但鏈表不具備隨機訪問性.這個很容易理解.數組在內存里是連續的空間.比如如果一個數組地址從100到200,且每個元素佔用兩個位元組,那麼100-200之間的任何一個偶數都是數組元素的地址.可以直接訪問.鏈表在內存地址可能是分散的.所以必須通過上一節點中的信息找能找到下一個節點.
3.查找速度上.這個也是因為內存地址的連續性的問題.不羅索了.
鏈表優於數組的:
1.插入與刪除的操作.如果數組的中間插入一個元素,那麼這個元素後的所有元素的內存地址都要往後移動.刪除的話同理.只有對數據的最後一個元素進行插入刪除操作時,才比較快.鏈表只需要更改有必要更改的節點內的節點信息就夠了.並不需要更改節點的內存地址.
2.內存地址的利用率方面.不管你內存里還有多少空間,如果沒辦法一次性給出數組所需的要空間,那就會提示內存不足,磁碟空間整理的原因之一在這里.而鏈表可以是分散的空間地址.
3.鏈表的擴展性比數組好.因為一個數組建立後所佔用的空間大小就是固定的.如果滿了就沒法擴展.只能新建一個更大空間的數組.而鏈表不是固定的,可以很方便的擴展.

建議樓主看一些數據結構的書,是很重要的.

Ⅱ python array list

第三題，
>>> import numpy as np
>>> a = np.array([[1,2],[3,4]])
>>> b=a.tolist()
>>> b
[[1, 2], [3, 4]]
第二題，用上面的方法
>>> import numpy as np
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[2,3],[4,5]])
>>> a.tolist()==b.tolist()
False
>>> c = np.array([[1,2],[3,4]])
>>> a.tolist()==c.tolist()
True

Ⅲ 關於ArrayList的toArray（T[]）方法求解

toArray 的源代碼是：

publicObject[]toArray(Objectaobj[])
{
if(aobj.length<size)
return(Object[])Arrays.Of(elementData,size,((Object)(aobj)).getClass());
System.array(((Object)(elementData)),0,((Object)(aobj)),0,size);
if(aobj.length>size)
aobj[size]=null;
returnaobj;
}

可以看出，是把ArrayList 的數據復制到new String[0]，然後把這個值返回，0這個參數只是操作一次復制多少個，對返回結果沒啥影響，(String[]) 這個是強轉，由於ArrayList 可以放任何對象，所以如果提前知道是什麼類型，可以通過強轉來實現。

Ⅳ Array List

s中每次都添加player.PlayerPosition，而player.PlayerPosition只有一個，所以for每次循環中取出來的都是同樣的player.PlayerPosition的值。可以通過類似s.add(new Position(player.PlayerPosition.X,player.PlayerPosition.Y))的代碼來達到你想要的效果。

Ⅳ Java基礎：數組Array轉成List的幾種方法

代碼片段(3)[全屏查看所有代碼]1. [代碼]數組->List (StringArrayTest.java) import java.util.Arrays; import java.util.List; import java.util.ArrayList; public class StringArrayTest { public static void main(String[] args) { String[] words = {"ace", "boom", "crew", "dog", "eon"}; List<String> wordList = Arrays.asList(words); for (String e : wordList) { System.out.println(e); } } }2. [代碼]比較傻的做法 String[] words = { ... }; List<String> list = new ArrayList<String>(words.length); for (String s : words) { list.add(s); }3. [代碼]這方法也還可以 import java.util.Collections; List myList = new ArrayList(); String[] myStringArray = new String[] {"Java", "is", "Cool"}; Collections.addAll(myList, myStringArray);

Ⅵ Array List

等於你的arraylist裡面有兩個完全一樣的point對象,改了後一個也會影響前一個,它們指向相同的內存地址.要這樣寫 s.add(new Point(3,3));

Ⅶ Java array 和array list 很簡單

題目的 意思大概就是想用 ArrayList給數組賦值

參考代碼如下

importjava.util.ArrayList;
importjava.util.Arrays;

publicclassCustomerLister{
	publicstaticvoidmain(String[]args){	
		ArrayList<String>list=newArrayList<String>();
		list.add("Cathy");
		list.add("Ben");
		list.add("Jorge");
		list.add("Wanda");
		list.add("Freddie");
		
		String[]customerName=newString[5];
		for(inti=0;i<customerName.length;i++){
			customerName[i]=list.get(i);
		}
		
		System.out.println(Arrays.toString(customerName));
		
	}
}

Ⅷ 請教關於java中的Arrays.asList的用法

import java.util.*;

class Snow {}
class Powder extends Snow {}
class Crusty extends Snow {}
class Slush extends Snow {}

class Light extends Powder {}
class Heavy extends Powder {}

public class ArrayListClass {
public static void main(String[] args) {
List<Snow> snow1 = Arrays.asList(
new Crusty(), new Slush(), new Powder(),new Light(),new Heavy() );
//進行的對比
List<Snow> snow3 = new ArrayList<Snow>();
Collections.addAll(snow3, new Light(), new Heavy());
}
}

Ⅸ list與arraylist 區別

List和ArrayList的區別在於：

1、在編程語言中ArrayList類是.Net Framework提供的用於數據存儲和檢索的專用類。List 類可以簡單視之為雙向連結串列，以線性列的方式管理物件集合。List類是ArrayList類的泛型等效類。

2、ArrayList繼承了IList介面，所以它可以很方便的進行數據的添加，插入和移除。List的大部分用法都與ArrayList相似，List類也繼承了IList介面。

3、在ArrayList中可以插入不同類型的數據。ArrayList會把所有插入其中的數據都當作為object類型來處理，這其中存在裝箱與拆箱的操作，會對系統造成性能上的損耗。而List需要聲明其數據的對象類型。聲明後插入其他類型數據，IDE就會報錯，且不能通過編譯。

(9)arraylist常用方法擴展閱讀：

一、List泛型

通過允許指定泛型類或方法操作的特定類型，泛型功能將類型安全的任務從程序員轉移給了編譯器。不需要編寫代碼來檢測數據類型是否正確，因為會在編譯時強制使用正確的數據類型。減少了類型強制轉換的需要和運行時錯誤的可能性。泛型提供了類型安全但沒有增加多個實現的開銷。

二、裝箱與拆箱的概念：

1、裝箱：就是將值類型的數據打包到引用類型的實例中 比如將int類型的值123賦給object對象o

int i=123; object o=(object)i;

2、拆箱：就是從引用數據中提取值類型 比如將object對象o的值賦給int類型的變數i

object o=123; int i=(int)o;

3、裝箱與拆箱的過程是很損耗性能的。

Ⅹ 關於Array和List的區別

Array和List都屬於順序表。
Array是一段連續的存儲結構
int[] i=new int[3]
i其實記錄的是數組的首地址，而i[1]其實相當於在i的地址的基礎上加上1個整數的地址偏移，然後再取這塊地址中的值。

List則是不連續的存儲結構,List的每個節點都有著一個Next屬性，這個屬性則記錄著他的下一個節點的地址。
也就是說當我們想找第100個節點的時候，他還是需要從第一個節點，然後做99次Next操作，才能找到list[99]節點。
在查找一個元素時時分別生成以下IL碼

Array:

IL_0020: ldloc.0

IL_0021: ldc.i4.3

IL_0022: ldelem.i4

IL_0023: stloc.2

List:

IL_0022: ldloc.0

IL_0023: ldc.i4.3

IL_0024: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1<int32>::get_Item(int32)

IL_0029: stloc.2

通過這兩段IL，我只是希望證明List和Array對索引元素的方式是不同的。當然，我們無從知道Microsoft對List方法get_Item的實現。但是我們不難想像：

因為List是一個鏈表，所以我需要從第一個元素開始逐個Next到所需索引的元素。這是一個耗時的過程。

1. 從空間擴展角度上來說：

數組必須要在初始化時分配固定的大小，比如說int[] a=new int[3];如果我們僅僅寫int[] a=new int[];編譯器就會無情地給我們報錯。但是List由於空間不必連續，所以無須指定初始大小。

總結1： 當不確定大小時，最好使用List代替Array。

2. 從操作角度上來看：

關於索引這個就不贅述了。

總結2：當需要大量的查找操作時，最好使用Array。

對於插入（刪除）操作，很多人是從插入（刪除）的時間上分析，說List優於Array，我覺得是不合理的。

更合理的解釋應該是從兩個角度分析（以插入為例）：

<1> 指定位置插入指定元素：

對於Array講，有兩套解決方案：

A. 使用一個新數組，N+1個元素重新賦值的過程。一個for循環，時間復雜度O(n)。

B. 在原數組上操作，那麼首先需要為該數組預留空間，這是個很難辦的事情。而且其後續元素的移動耗費時間復雜度仍未O(n)。

對於List來講，很多人說復雜度就是O(1)。這其實是不合理的，因為List插入元素固然容易，但是在指定位置的插入，需要一個時間復雜度為O(n)的查找過程。

但是只考慮時間復雜度是不夠的，我們要考慮總體的情況。如果使用新數組，不僅浪費了新的空間，而且需要反復的賦值過程，是N+1次。如果不使用新數組，預留空間實在太麻煩，因此綜上所述，還是List好。

<2> 給出前一個節點，然後在後面插入元素。這個我的意思就是不僅僅給出了PreviousNode的Value，還給出了他的Next。這個情況我就不廢話了，List的優勢太大了。可是在實際情況中，這種情況的可能性幾乎為零。

因此，總結3：當需要進行頻繁的插入，刪除操作時，最好使用List代替Array。

另外，給出個不太重要的補充，由於List需要存儲他下一個節點的地址，所以List比Array相對起來浪費了更多的空間。

也就是說雖然使用list<T>強類型範性，能夠節約裝箱拆箱時間，但查詢速度會有很多問題。
在實際使用中，對變化不大，查詢次數頻繁的，我們應該考慮list<T>外的情況
當然，就查詢某個值的速度而言，還是 Hashtable 或 Dictionary 最快，當然這兩者和我們在討論的東西，結構完全不相同，沒有可比性。畢竟數組，是節約空間，而hash表是散列的，犧牲空間來換取速度