C#中[],List,Array,ArrayList的区别于应用，有需要的朋友可以参考下。[] 是针对特定类型、固定长度的。List 是针对特定类型、任意长度的。Array 是针对任意类型、固定长度的。ArrayList 是针对任意类型、任意长度的。Array 和 ArrayList 是通过存储 object 实现任意类型的，所以使用时要转换。using S using System.Collections.G using System.L using System.W using System.Web.UI; using System.Web.UI.WebC using System.C public partial class _Default : System.Web.UI.Page {
protected void Page_Load(object sender, EventArgs e)
{ // System.Int32 是结构 int[] arr = new int[] { 1, 2, 3 }; Response.Write(arr[0]); // 1 Change(arr); Response.Write(arr[0]); // 2 // List 的命名空间是 System.Collections.Generic List&int& list = new List&int&(); list.Add(1); list.Add(2); list.Add(3); Response.Write(list[0]); // 1 Change(list); Response.Write(list[0]); // 2 // Array 的命名空间是 System Array array = Array.CreateInstance(System.Type.GetType(&System.Int32&), 3); // Array 是抽象类，不能使用 new Array 创建。 array.SetValue(1, 0); array.SetValue(2, 1); array.SetValue(3, 2); Response.Write(array.GetValue(0)); // 1 Change(array); Response.Write(array.GetValue(0)); // 2 // ArrayList 的命名空间是 System.Collections ArrayList arrayList = new ArrayList(3); arrayList.Add(1); arrayList.Add(2); arrayList.Add(3); Response.Write(arrayList[0]); // 1 Change(arrayList); Response.Write(arrayList[0]); // 2
private void Change(int[] arr)
{ for (int i = 0; i & arr.L i++) { arr[i] *= 2; }
private void Change(List&int& list)
{ for (int i = 0; i & list.C i++) // 使用 Count { list[i] *= 2; }
private void Change(Array array)
{ for (int i = 0; i & array.L i++) // 使用 Length { array.SetValue((int)array.GetValue(i) * 2, i); // 需要类型转换 }
private void Change(ArrayList arrayList)
{ for (int i = 0; i & arrayList.C i++) // 使用 Count { arrayList[i] = (int)arrayList[i] * 2; // 需要类型转换 }
} }另外：把一个对象数组转换成ArrayList可以使用ArrayList.Adapter方法。这个方法把一个IList包裹在一个ArrayLIst里。Person[] personArray = myPerson.GetPersons();ArrayList personList = ArrayList.Adapter(personArray); 把一个ArrayList转换成对象数组可以使用ArrayList.ToArray方法。Person[] personArrayFromList = (Person[])personList.ToArray(typeof(Person)); 不要忘了在调用ArrayList.ToArray方法之前进行强制类型转换，否则在编译的时候会出错提示你不能把一个ArrayList转换成Person对象数组。C#中数组、ArrayList和List三者的区别
最新教程周点击榜
微信扫一扫数组与List之间相互转换的方法详解
字体：[ ] 类型：转载 时间：
本文是对数组与List之间相互转换的方法进行了详细的分析介绍，需要的朋友可以过来参考下。希望对大家有所帮助
1.List转换成为数组。（这里的List是实体是ArrayList) 调用ArrayList的toArray方法。
public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分配一个新的数组。
如果指定的数组能容纳列表并有剩余空间（即数组的元素比列表的多），那么会将数组中紧跟在集合末尾的元素设置为 null。这对确定列表的长度很有用，但只 在调用方知道列表中不包含任何 null 元素时才有用。
接口 Collection 中的 toArray
接口 List 中的 toArray
类 AbstractCollection 中的 toArray
a - 要存储列表元素的数组，如果它足够大的话；否则，它是一个为存储列表元素而分配的、具有相同运行时类型的新数组。
包含列表元素的数组。
ArrayStoreException - 如果 a 的运行时类型不是此列表中每个元素的运行时类型的超类型。 具体用法：
代码如下:List list = new ArrayList();
list.add("1");
list.add("2");
final int size = list.size();
String[] arr = (String[])list.toArray(new String[size]);2.数组转换成为List调用Arrays的asList方法.
JDK 1.4对java.util.Arrays.asList的定义，函数参数是Object[]。所以，在1.4中asList()并不支持基本类型的数组作参数。
JDK 1.5中，java.util.Arrays.asList的定义，函数参数是Varargs, 采用了泛型实现。同时由于autoboxing的支持，使得可以支持对象数组以及基本类型数组。
不过在使用时，当传入基本数据类型的数组时，会出现小问题，会把传入的数组整个当作返回的List中的第一个元素，例如： 代码如下:public static void main(String[] args){&&& int[] a1 = new int[]{1,2,3};&&& String[] a2 = new String[]{"a","b","c"};&&& System.out.println(Arrays.asList(a1));&&& System.out.println(Arrays.asList(a2));}1.打印结果如下： 代码如下:12 [[I@dc8569][a, b, c] 下面说说Arrays.asList()的返回值：
JDK文档是这么说的：public static &T& List&T& asList(T... a) 返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。此方法还提供了一个创建固定长度的列表的便捷方法，该列 代码如下:/**&* @serial include&*/&private static class ArrayList&E&extends AbstractList&E&implements RandomAccess, java.io.Serializable {&&&& private static final long serialVersionUID = -8945198L;&&&& private final E[]&&&& ArrayList(E[] array) {&&&&&&&& if (array == null)&&&&&&&& throw new NullPointerException();&&&&&&&& a =&&&& }&&&& public int size() {&&&&&&& return a.&&&& }&&&& public Object[] toArray() {&&&&&&& return a.clone();&&&& }&&&& public &T& T[] toArray(T[] a) {&&&&&&&& int size = size();&&&&&&&& if (a.length & size)&&&&&&&&&&& return Arrays.copyOf(this.a, size, (Class&? extends T[]&) a.getClass());&&&&&&&& System.arraycopy(this.a,0, a, 0, size);&&&&&&&& if (a.length & size)&&&&&&&&&&& a[size] =&&&&&&&&&&&& }&&&& public E get(int index) {&&&&&&& return a[index];&&&& }&&&& public E set(int index, E element) {&&&&&&&& E oldValue = a[index];&&&&&&&& a[index] =&&&&&&&& return oldV&&&& }&&&& public int indexOf(Object o) {&&&&&&&& if (o == null) {&&&&&&&&&&&& for (int i = 0; i & a. i++)&&&&&&&&&&&& if (a[i] == null)&&&&&&&&&&&&&&&&&&&& }else {&&&&&&&&&&&& for (int i = 0; i & a. i++)&&&&&&&&&&&& if (o.equals(a[i]))&&&&&&&&&&&&&&&&&&&& }&&&&&&&& return -1;&&&& }&&&& public boolean contains(Object o) {&&&&&&& return indexOf(o) != -1;&&&& }}表被初始化为包含多个元素： List&String& stooges = Arrays.asList("Larry", "Moe", "Curly");我们都知道，List的一个典型的特性就是其长度是可变的，我们可以很方便地对它进行插入和删除元素的操作，这是它与数组所存在的一个很大的区别，后者的长度是固定的，而且我们不能从数组中删除元素，只能修改元素的值。利用Arrays.asList(array)将返回一个List，然而这个返回的List并不支持add和remove的操作。
这是什么原因呢？
Arrays.asList源码： 代码如下:123 public static &T& List&T& asList(T... a) {&& return new ArrayList&T&(a);} 这里的ArrayList并不是java.util.ArrayList，而是Arrays的内部类：
我们可以看到该内部类继承的是AbstractList，下面是AbstractList的add和remove方法源码： 代码如下:public boolean add(E e) {&&& add(size(), e);&&&}public void add(int index, E element) {&&& throw new UnsupportedOperationException();}public E remove(int index) {&&& throw new UnsupportedOperationException();}所以，当我们对Arrays.asList返回的List进行添加或删除时将会报 java.lang.UnsupportedOperationException 异常。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具比较Java数组和各种List的性能小结
投稿：daisy
字体：[ ] 类型：转载 时间：
这篇文章主要是分别对Java数组、ArrayList、LinkedList和Vector进行随机访问和迭代等操作，并比较这种集合的性能。有需要的可以参考借鉴。
话不多说，直接看示例代码
package cn.lion.
public class PerformanceTest {
privatestatic final int SIZE =100000;
publicstatic abstract class Test{
publicTest(String operation){
this.operation=
publicabstract void test(List&String& list);
publicString getOperation(){
//执行迭代操作的匿名类
staticTest iterateTest = new Test("iterate"){
publicvoid test(List&String& list){
for(inti=0; i&10; i++){
Iterator&String&it = list.iterator();
while(it.hasNext()){
it.next();
//执行随机访问的匿名类
staticTest getTest = new Test("get"){
publicvoid test(List&String& list){
for(inti=0; i&list.size(); i++){
for(intk=0; k&10; k++){
list.get(k);
//执行插入的匿名类
staticTest insertTest = new Test("insert"){
publicvoid test(List&String& list){
ListIterator&String&it = list.listIterator(list.size()/2);
for(inti=0; i&SIZE; i++){
it.add("lion");
//执行删除的匿名类
staticTest removeTest = new Test("remove"){
publicvoid test(List&String& list){
ListIterator&String&it = list.listIterator();
while(it.hasNext()){
it.next();
it.remove();
staticpublic void testArray(List&String& list){
Test[]tests = {iterateTest, getTest};
test(tests,list);
staticpublic void testList(List&String& list){
Test[]tests = {insertTest, iterateTest, getTest, removeTest};
test(tests,list);
staticpublic void test(Test[] tests, List&String& list){
for(inti=0; i&tests. i++){
System.out.print(tests[i].getOperation()+ "操作：");
longt1 = System.currentTimeMillis();
tests[i].test(list);
longt2 = System.currentTimeMillis();
System.out.print(t2-t1+ "ms");
System.out.println();
publicstatic void main(String[] args){
List&String&list =
//测试数组的迭代和随机访问操作
System.out.println("------测试数组------");
String[]tstr = new String[SIZE];
Arrays.fill(tstr,"lion");
list= Arrays.asList(tstr);
testArray(list);
tstr= new String[SIZE/2];
Collection&String&coll = Arrays.asList(tstr);
//测试Vector
System.out.println("------测试Vector------");
list= new Vector&String&();
list.addAll(coll);
testList(list);
//测试LinkedList
System.out.println("------测试LinkedList------");
list= new LinkedList&String&();
list.addAll(coll);
testList(list);
//测试ArrayList
System.out.println("------测试Vector------");
list= new ArrayList&String&();
list.addAll(coll);
testList(list);
运行结果如图
从结果可以看出，对数组进行随机访问和迭代操作的速度是最快的；对LinkedList进行插入和删除操作的速度是最快的；对ArrayList进行随机访问的速度也很快；Vector类在各方面没有突出的性能，且此类已不提倡使用了。
以上就是本文的全部内容，希望对大家学习或者使用Java能有所帮助。如果有疑问可以留言讨论。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具List 是针对特定类型、任意长度的。
Array 是针对任意类型、固定长度的。
ArrayList 是针对任意类型、任意长度的。
Array 和 ArrayList 是通过存储 object 实现任意类型的，所以使用时要转换。
在C#中数组，ArrayList，List都能够存储一组对象，那么这三者到底有什么样的区别呢。
&&& 数组在C#中最早出现的。在内存中是连续存储的，所以它的索引速度非常快，而且赋值与修改元素也很简单。
[csharp]&&
&&& 但是数组存在一些不足的地方。在数组的两个数据间插入数据是很麻烦的，而且在声明数组的时候必须指定数组的长度，数组的长度过长，会造成内存浪费，过段会造成数据溢出的错误。如果在声明数组时我们不清楚数组的长度，就会变得很麻烦。
&&& 针对数组的这些缺点，C#中最先提供了ArrayList对象来克服这些缺点。&
&&& ArrayList是命名空间System.Collections下的一部分，在使用该类时必须进行引用，同时继承了IList接口，提供了数据存储和检索。ArrayList对象的大小是按照其中存储的数据来动态扩充与收缩的。所以，在声明ArrayList对象时并不需要指定它的长度。
[csharp]&&
&&& 从上面例子看，ArrayList好像是解决了数组中所有的缺点，为什么又会有List？
&&& 我们从上面的例子看，在List中，我们不仅插入了字符串cde，而且插入了数字5678。这样在ArrayList中插入不同类型的数据是允许的。因为ArrayList会把所有插入其中的数据当作为object类型来处理，在我们使用ArrayList处理数据时，很可能会报类型不匹配的错误，也就是ArrayList不是类型安全的。在存储或检索值类型时通常发生装箱和取消装箱操作，带来很大的性能耗损。
&&& 装箱与拆箱的概念：
&&& 简单的说:
&&&&装箱：就是将值类型的数据打包到引用类型的实例中
&&& 比如将string类型的值abc赋给object对象obj
[csharp]&&
&&&&拆箱：就是从引用数据中提取值类型
&&& 比如将object对象obj的值赋给string类型的变量i
[csharp]&&
&&&&装箱与拆箱的过程是很损耗性能的。&
&&& 因为ArrayList存在不安全类型与装箱拆箱的缺点，所以出现了泛型的概念。List类是ArrayList类的泛型等效类，它的大部分用法都与ArrayList相似，因为List类也继承了IList接口。最关键的区别在于，在声明List集合时，我们同时需要为其声明List集合内数据的对象类型。
[csharp]&&
&&& 上例中，如果我们往List集合中插入int数组123，IDE就会报错，且不能通过编译。这样就避免了前面讲的类型安全问题与装箱拆箱的性能问题了。
&&& 数组的容量是固定的，您只能一次获取或设置一个元素的值，而ArrayList或List&T&的容量可根据需要自动扩充、修改、删除或插入数据。
&&& 数组可以具有多个维度，而 ArrayList或 List& T& 始终只具有一个维度。但是，您可以轻松创建数组列表或列表的列表。特定类型（Object 除外）的数组 的性能优于 ArrayList的性能。 这是因为 ArrayList的元素属于 Object 类型；所以在存储或检索值类型时通常发生装箱和取消装箱操作。不过，在不需要重新分配时（即最初的容量十分接近列表的最大容量），List& T& 的性能与同类型的数组十分相近。
&&& 在决定使用 List&T& 还是使用ArrayList 类（两者具有类似的功能）时，记住List&T& 类在大多数情况下执行得更好并且是类型安全的。如果对List& T& 类的类型T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型T使用值类型，则需要考虑实现和装箱问题。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：20846次
积分：2161
积分：2161
排名：第14960名
原创：173篇
转载：167篇
天马脚下，岳麓山前所感所思（3）
有些知识点可能平时一直在使用，不过实际开发中我们可能只是知其然不知其所以然，所以经常的总结会对我们的提高和进步有很大的帮助，这里记录自己在工作之余的问题，持续更新，欢迎高手斧正.
　　数组、List和ArrayList的区别
　　数组在内存中是连续存储的，所以它的索引速度是非常的快，而且赋值与修改元素也很简单，比如：
string[] s=new string[3];
//赋值
s[0]=&a&; s[1]=&b&; s[2]=&c&;
s[1]=&b1&;
　　但是数组也存在一些不足的地方。比如在数组的两个数据间插入数据也是很麻烦的，还有我们在声明数组的时候，必须同时指明数组的长度，数组的长度过长，会造成内存浪费，数组和长度过短，会造成数据溢出的错误。这样如果在声明数组时我们并不清楚数组的长度，就变的很麻烦了。C#中最先提供了ArrayList对象来克服这些缺点。
　　ArrayList是.Net Framework提供的用于数据存储和检索的专用类，它是命名空间System.Collections下的一部分。它的大小是按照其中存储的数据来动态扩充与收缩的。所以，我们在声明ArrayList对象时并不需要指定它的长度。ArrayList继承了IList接口，所以它可以很方便的进行数据的添加，插入和移除.比如：
ArrayList list = new ArrayList();
//新增数据
list.Add(&abc&); list.Add(123);
//修改数据
list[2] = 345;
//移除数据
list.RemoveAt(0);
//插入数据
list.Insert(0, &hello world&);
　　从上面示例看，ArrayList好像是解决了数组中所有的缺点，那么它应该就是完美的了，为什么在C#2.0后又会出现List呢？
　　在list中，我们不仅插入了字符串&abc&，而且又插入了数字123。这样在ArrayList中插入不同类型的数据是允许的。因为ArrayList会把所有插入其中的数据都当作为object类型来处理。这样，在我们使用ArrayList中的数据来处理问题的时候，很可能会报类型不匹配的错误，也就是说ArrayList不是类型安全的。既使我们保证在插入数据的时候都很小心，都有插入了同一类型的数据，但在使用的时候，我们也需要将它们转化为对应的原类型来处理。这就存在了装箱与拆箱的操作，会带来很大的性能损耗。
　　装箱与拆箱的概念： 简单的来讲: 装箱：就是将值类型的数据打包到引用类型的实例中 比如将int类型的&#赋给object对象o
　　int i=123; object o=(object)i;
　　拆箱：就是从引用数据中提取值类型 比如将object对象o的值赋给int类型的变量i
　　object o=123; int i=(int)o;
　　装箱与拆箱的过程是很损耗性能的。
　　正是因为ArrayList存在不安全类型与装箱拆箱的缺点，所以在C#2.0后出现了泛型的概念。而List类是ArrayList类的泛型等效类。它的大部分用法都与ArrayList相似，因为List类也继承了IList接口。最关键的区别在于，在声明List集合时，我们同时需要为其声明List集合内数据的对象类型。 比如：
List&int& list = new List&int&();
//新增数据
list.Add(123);
//修改数据
list[0] = 345;
//移除数据
list.RemoveAt(0);
　　上例中，如果我们往List集合中插入string字符&hello world&，IDE就会报错，且不能通过编译。这样就避免了前面讲的类型安全问题与装箱拆箱的性能问题了。
　　同时&List不能被构造，但可以向上面那样为List创建一个引用，而ListArray就可以被构造。&
List list=new List();
是错误的用法
　　List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。&而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。&
　　List泛型的好处：&
　　通过允许指定泛型类或方法操作的特定类型，泛型功能将类型安全的任务从您转移给了编译器。不需要编写代码来检测数据类型是否正确，因为会在编译时强制使用正确的数据类型。减少了类型强制转换的需要和运行时错误的可能性。泛型提供了类型安全但没有增加多个实现的开销。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1512次
排名：千里之外
(2)(3)(1)(2)(1)(1)(2)(1)