Java的数组(Array)、Vector、ArrayList、HashMap的异同

Java的数组（Array）、Vector、ArrayList、Hash Map的异同

array(数组)和Vector是十分相似的Java构件（constructs），两者全然不同，在选择使用时应根据各自的功能来确定。

1、数组：

Array可以存放Object和基本数据类型，但创建时必须指定数组的大小，并不能再改变。值得注意的是：当Array中的某一元素存放的是Object reference 时，Java不会调用默认的构造函数，而是将其初值设为null，当然这跟Java对各类型数据赋默认值的规则是一样的，对基本数据类型同样适用。

2、Array：

实现了List接口，功能与Fetor一样，只是没有同步机制，当然元素的访问方式为从List 中继承而来，可存放任何类型的对象。

3、Vector：

对比于Array，当更多的元素被加入进来以至超出其容量时，Vector的size会动态增长，而Array容量是定死的。同时，Vector在删除一些元素后，其所有下标大于被删除元素的元素都依次前移，并获得新下标比原来的小了）。注意：当调用Vector的size()方法时，返回Vector 中实际元素的个数。

Vector内部实际是以Array实现的，也通过元素的整数索引来访问元素，但它只能存放https://www.360docs.net/doc/006529993.html,ng.Object对象，不能用于存放基本类型数据，比如要存放一个整数10,得用new Integer(10)构造出一个Integer包装类对象再放进去。当Vector中的元素个数发生变化时, 其内部的Array必须重新分配并进行拷贝，因此这是一点值得考虑的效率问题。

Vetor同时也实现了List接口，所以也可以算作Colletion了，只是它还特殊在：Vector is synchronized。即Vetor对象自身实现了同步机制。

4、HashMap：

继承了Map接口，实现用Keys来存储和访问Values，Keys和Values都可以为空，它与Hashtable类的区别在于Hashtable类的Keys不能为null,并Hashtable类有同步机制控制，而HashMap类没有。

在Struts类库中实现了一个LableValueBean，用Lable（Key）来存储和访问Value，很方便。

Java数组与Java基础类实验报告

西安邮电大学（计算机学院）课内实验报告实验名称：数组与Java基础类专业名称：计算机科学与技术班级：计科1405班学生姓名：高宏伟学号：04141152 指导教师：刘霞林实验日期：2016.10.27

一、实验目的掌握Java中的数组定义、引用，掌握String类和StringBuffer类的使用。二、实验要求 1．编写一个使用Java 数组的的程序。 2．编写一个使用String类的程序。 3．编写一个使用StringBuffer类的程序。三、实验内容 (一) 使用数组求Fibonacci数列前10项之和 1.编写程序。 public class Fibonacci { public static void main(String args[]){ int i=0,j=1,s=0; for(int n=1;n<=5;n++){ s+=(i+j); i = (int)(i+j); j = (int)(i+j); } System.out.print("前10项之和是："+s); } } 2.编译并运行程序。（二）练习String类的常用方法 ?实验要求：编写一个Java应用程序，判断两个字符串是否相同，判断字符串的前缀、后缀是否和某个字符串相同，按字典顺序比较两个字符串的大小关系，检索字符串，创建字符串，将数字型字符串转换为数字，将字符串存放到数组中，用字符数组创建字符串。。 ?程序模板： StringExample.java class StringExample { public static void main(String args[]) { String s1=new String("you are a student"),s2=new String("how are you"); if(【代码1】) // 使用equals方法判断s1与s2是否相同 { System.out.println("s1与s2相同"); }

C++定义动态数组

C++定义动态数组首先：为什么需要动态定义数组呢？这是因为，很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出但是问题是，c++要求定义数组时，必须明确给定数组的大小，要不然编译通不过如：int Array[5];正确 int i=5; int Array[i]; 错误因为在编译阶段，编译器并不知道i 的值是多少那么，我们该如何解决定义长度未知的数组呢？答案是：new 动态定义数组因为new 就是用来动态开辟空间的，所以当然可以用来开辟一个数组空间这样，下面的语句： int size=50; int *p=new int[size]; 是正确的但是二维动态数组能不能也这样定义呢 int size=50,Column=50; int (*p)[Column]=new int [size][Column] 这样的语句，编译器通不过，为什么呢？首先new int[size][Column] 就是动态生成时确定的，所以它没有错那么就是int（*p）[Column]，这句有问题了，这句为什么不对呢，那是因为，这是一个定义语句，而定义语句先经过编译器进行编译，当编译器运行到此处时，发现Column 不是常数，因此不能通过编译。而之所以编译器认为Column 不是常数，是因为编译阶段，编译器起的作用是查语法错误，和预分配空间，它并不执行程序，因此，没有执行那个赋值语句（只是对这个语句检查错误，和分配空间），因此编译阶段，它将认为column 是个变量。所以上面的二维数组定义是错误的，它不能通过编译。改成这样： int size=50 int (*p)[50]=new int [size][50] 便正确了。由此可见，这种动态分配数组，仅对一维数组空间是真正动态分配的。但是如何真正的动态分配二维数组呢，即如果Column 也不能预先知道的话，该如何处理呢？上面的动态分配已经不能满足我们的要求，因为上面动态分配只对一维数组是真正动态的，对二维

JAVA类与对象及数组习题及答案

JAV A类和对象及数组习题一、选择题（1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用（2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步（3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个（5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。

如何在VC中创建动态数组

如何在VC中创建动态数组怎样给多维数组动态分配内存 //Allocate: int **p = new int* [m]; for(int i = 0 ; i < m ; i++) p[i] = new int[n]; //Use: for(int i = 0 ; i < m; i++) for(int j = 0 ; j < n ; j++) p[i][j] = i * j; //Free: for(int i = 0 ; i < m ; i++) delete[] p[i]; delete[] p; 1. 演示形为int[2][3]的二维动态数组 /////////////////////////////////////////////////////////////////// int n1, n2; const int DIM1 = 2; const int DIM2 = 3; // 构造数组 int **ppi = new int*[DIM1]; for(n1 = 0; n1 < DIM1; n1++) { ppi[n1] = new int[DIM2]; } // 填充数据 for(n1 = 0; n1 < DIM1; n1++) { for(n2 = 0; n2 < DIM2; n2++) { ppi[n1][n2] = n1 * 10 + n2; } } // 输出 for(n1 = 0; n1 < DIM1; n1++) { for(n2 = 0; n2 < DIM2; n2++) {

afxDump << "ppi[" << n1 << "][" << n2 << "] = " << ppi[n1][n2] << "\n"; } } // 释放数组 for(n1 = 0; n1 < DIM1; n1++) { delete [] ppi[n1]; } delete [] ppi; 2. 三维动态数组（int[2][3][4]） /////////////////////////////////////////////////////////////////// int n1, n2, n3; const int DIM1 = 2; const int DIM2 = 3; const int DIM3 = 4; // 构造数组 int ***ppi = new int**[DIM1]; for(n1 = 0; n1 < DIM1; n1++) { ppi[n1] = new int*[DIM2]; for(n2 = 0; n2 < DIM2; n2++) { ppi[n1][n2] = new int[DIM3]; } } // 填充数据 for(n1 = 0; n1 < DIM1; n1++) { for(n2 = 0; n2 < DIM2; n2++) { for(n3 = 0; n3 < DIM3; n3++) { ppi[n1][n2][n3] = n1 * 100 + n2 * 10 + n3; } } } // 输出 for(n1 = 0; n1 < DIM1; n1++) { for(n2 = 0; n2 < DIM2; n2++) { for(n3 = 0; n3 < DIM3; n3++)

Java类类型的数组创建与使用方法

Java类数组的使用方法一注意一定要把类数组的每一个元素都赋值，否则就报错，既对类数组对象的一空声明，如果并没有实例化，会报空指针异常：NullPointerException 1.创建类类型的数组方法一：创建一个Person类，在main方法中创建p1,p2,p3,p4 几个Person 类的实例化对象。然后再使用如下代码创建类类型的数组p。Product [] p=new Product[]{p1,p2,p3,p4}; public class Test { public static void main(String[] args) { Product p1=new Product(); https://www.360docs.net/doc/006529993.html,="豆浆机"; Product p2=new Product(); https://www.360docs.net/doc/006529993.html,="电视机"; Product p3=new Product(); Product p4=new Product(); Product [] p=new Product[]{p1,p2,p3,p4};//创建类类型的数组方法一 for(int i=0;i

} } class Product{ int Num; String name; } 2.创建类类型的数组方法二： public class Test { public static void main(String[] args) { Product p1=new Product(); Product p2=new Product(); Product p3=new Product(); Product p4=new Product(); Product [] p={p1,p2,p3};//创建类类型的数组方法二for(int i=0;i

c#中动态数组的使用

在向大家详细介绍C#动态数组之前，首先让大家了解下C#动态数组的方法及属性，然后全面介绍C#动态数组。下面的例子向你演示C#动态数组的方法及属性，这样通过实例的演示介绍能够更加深刻的理解C#动态数组的各项基本概念和应用，希望对你有所帮助。 C#动态数组的详解实例： 1.ArrayList AL = new ArrayList(); 2.AL.Add("Hello"); 3.AL.Add(" World"); 4.Console.WriteLine("给数组添加元素："); 5.foreach (Object obj in AL) 6.{ Console.Write(obj); } 7.Console.WriteLine(); 8.Console.WriteLine("个数:" + AL.Count); 9.Console.WriteLine("容量: " + AL.Capacity); 10.AL.Insert(1, " c#"); 11.//C#动态数组的详解实例 12.Console.Write("在索引值为1的地方插入 "); 13.foreach (Object obj in AL) 14.{Console.Write(obj); } 15.Console.WriteLine(); 16.Console.WriteLine("个数:" + AL.Count); 17.Console.WriteLine("容量: "+AL.Capacity); 18.AL.Add("。");//给集合添加“。”，查看集合的容量 19.Console.WriteLine("容量。: " + AL.Capacity); 20.AL.Add("---");//给集合添加“---”，查看当集合的容量不够时，倍数变化 21.Console.WriteLine("容量---: " + AL.Capacity); 22.Console.WriteLine("3号索引的："+AL[3]); 23.//用索引方式获取集合元素值 24.//C#动态数组的详解实例 25.Console.WriteLine("数组中是否包含？："+AL.Contains ("?")); 26.//利用contains方法，查找集合中是否包含“？” 27.Console.WriteLine("经过之前操作后的数组元素："); 28.foreach (Object obj in AL) 29.{ Console.Write(obj); } 30.Console.WriteLine(); 31.Console.WriteLine("个数:" + AL.Count);

C语言中动态数组的实现

C语言中动态数组的实现 (2009-05-10 10:19:30) 转载分类：C语言学习标签： c中动态数组教育近来编写几个程序，很多都用到了数组。但是对于数组的大小却是没有固定的，也就是说可以更改数组大小，其大小是可以变化的。并不像初学时的那样，告诉你一个范围，你就必须取最大值以满足要求。那样可能就会浪费很多不必要的内存单元！那么到底应该怎样定义一个动态数组列？在数组一章中，曾介绍过数组的长度是预先定义好的，在整个程序中固定不变。C语言中不允许动态数组类型。例如： int n;scanf("%d",&n);int a[n]; 用变量表示长度，想对数组的大小作动态说明，这是错误的。但是在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。对于这种问题，用数组的办法很难解决。为了解决上述问题，C语言提供了一些内存管理函数，这些内存管理函数可以按需要动态地分配内存空间，也可把不再使用的空间回收待用，为有效地利用内存资源提供了手段。其它文献中所提到的"动态数组",指的就是利用内存的申请和释放函数,在程序的运行过程中，根据实际需要指定数组的大小.其本质是一个指向数组的指针变量.常用的内存管理函数有以下三个： 1.分配内存空间函数malloc 调用形式： (类型说明符*) malloc (size) 功能：在内存的动态存储区中分配一块长度为"size" 字节的连续区域。函数的返回值为该区域的首地址。“类型说明符”表示把该区域用于何种数据类型。(类型说明符*)表示把返回值强制转换为该类型指针。“size”是一个无符号数。例如： pc=(char *) malloc (100); 表示分配100个字节的内存空间，并强制转换为字符数组类型，函数的返回值为指向该字符数组的指针，把该指针赋予指针变量pc。 2.分配内存空间函数 calloc calloc 也用于分配内存空间。调用形式： (类型说明符*)calloc(n,size) 功能：在内存动态存储区中分配n块长度为“size”字节的连续区域。函数的返回值为该区域的首地址。(类型说明符*)用于强制类型转换。calloc函数与malloc 函数的区别仅在于一次可以分配n块区域。例如： ps=(struet stu*) calloc(2,sizeof (struct stu)); 其中的sizeof(struct stu)是求stu的结构长度。因此该语句的意思是：按stu的长度分配2块连续区域，强制转换为stu 类型，并把其首地址赋予指针变量ps。

Java_数组练习题目

一填空题 1)数组的元素通过数组下标来访问，数组Array的长度为元素的个数（Array.length）。 2)Java中数组的下标的数据类型是整形。 3)不用下标变量就可以访问数组的方法是数组名。 4)数组最小的下标是0 。 5)arraycopy()的最后一个参数指明复制元素的个数。 6)向方法传递数组参数时，传递的是数组的引用。 7)数组初始化包括数组的声明，创建，初始化。 8)数组下标访问超出索引范围时抛出数组越界异常 9)浮点型数组的默认值是0.0f 。 10)对象型数组的默认值是null 。二选择题 1.下面错误的初始化语句是_A B D__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B_ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是__B__ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是__D__ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为__C__ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是_B___ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表

c语言数组的动态分配

下面代码添加到头文件里面 #include #include struct data { int*p;//指针保存数组起始点 int length;//保存数组长度 int reallength;//实际分配内存长度 int state;//0代表无序，1代表有序从小到大，2代表有序从大到小 }; struct find { int**pp; int n; }; void init(struct data*pdata);//初始化 void reinit(struct data*pdata);//重新初始化 void addobject(struct data*pdata,int num);//增加一个元素 void addobjects(struct data*pdata,int*pnum,int n);//增加一个数组void printf1(struct data*pdata);//打印一个出来 void sort(struct data*pdata,int obj);//实现排序obj=0从小到大，否则从大到小 int*finddata(struct data*pdata,int num);//找到并返回第一次找到的地址void change(struct data*pdata,int oldnum,int newnum);//修改一个数据void insert(struct data*pdata,int num,int insertnum,int headback);//插入一个数据，0代表前插，1代表后插 void deleteone(struct data*pdata,int num);//删除第一个找到的数据 void deleteall(struct data*pdata,int num);//删除找到的全部数据 struct find findalldata(struct data*pdata,int num);//返回一片内存，包含所有找到的元素

Delphi之动态数组使用总结

Delphi之动态数组使用总结传统的Pascal 语言其数组大小是预先确定的，当你用数组结构声明数据类型时，你必须指定数组元素的个数。专业程序员也许知道些许动态数组的实现技术，一般是采用指针，用手工分配并释放所需的内存。 Delphi 4中增加了非常简单的动态数组实现方法，实现过程效仿我前面讲过的动态长字符串。与长字符串一样，动态数组的内存动态分配并且引用记数，不过动态数组不支持copy-on-write 技术。这不是个大问题，因为你可以把变量值设置为nil释放数组内存。这样你就可以声明一个不指定元素个数的数组，并用SetLength 过程给数组分配一个特定大小的内存，SetLength 过程还可以改变数组大小而不影响其内容，除此外还有一些字符串过程也可用于数组，如Copy 函数。以下摘录的代码突出了一点，这就是：定义数组后必须先为它分配内存，然后才能开始使用： procedure TForm1.Button1Click(Sender: TObject);var Array1: array of Integer;begin Array1 [1] := 100; // error SetLength (Array1, 100); Array1 [99] := 100; // OK ...end; 如果你只定义一个数组元素个数，那么索引总是从0开始。Pascal 中的普通数组既能用不为零的下标，也能用非整数的下标，但动态数组均不支持这两种下标。象普通数组一样，你可以通过Length、High和Low 函数了解到动态数组的状况，不过对于动态数组，Low 函数返回值总是0，High函数返回数组大小减1，这意味着空的动态数组其函数High返回值是-1，这是一个很怪的值，因为它比Low的返回值还小。图8.1:例DynArr 窗体以上作了简短的介绍，现在举个简例，例名DynArr ，见图8.1。例子实在是很简单，其实动态数组没有什么特别复杂地方。我想通过该例说明几个程序员可能犯的错误。程序中声明了两个全程数组并在OnCreate 事件中初始化了第一个数组： var Array1, Array2: array of Integer;procedure TForm1.FormCreate(Sender: TObject);begin // allocate SetLength (Array1, 100);end; 这样就把数组所有值设置为0。完成这段代码你马上就能读写数组元素的值，而不用害怕内存出错，当然条件是你没有试图访问超过数组上界的元素。为了更好地初始化，程序中添加了一个按钮，执行数组元素赋值操作：

java数组的概念和作用

1 数组的概念和其他语言一样，Java也提供数组支持，数组是属于引用类型，即数组是一个对象。强调数组的类型是引用类型。数组的基本概念及作用数组是相同数据类型元素的集合数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。数组的举例 int [] a = new int []{1,2,3,4,5}; String [] s = new String []{"小熊","小小熊","小小小熊"}; Employee [] e=new Employee[10];（Employee是自定义类） 2 数组的声明数组的声明的两种方式：数据类型 [] 数组名字例如：int [] a; 数据类型数组的名字 [] 例如： int a []; 注意：在Java语言中两种声明方法没有任何区别，但是建议大家用第一种，避免混淆a的数据类型。数组在声明后还只是一个空指针，不能使用，要想使用必须创建。数组创建的三种方式：

?//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值 char[] chAry = new char[10]; ?//声明数组并分配内存，同时将其初始化 ?int[] ary1 = new int[]{1, 2, 3, 4, 5}; ?//与前一种方式相同，仅仅只是语法相对简略 ?int[] ary2 = {1, 2, 3, 4, 5}; 从另一个角度，数组创建可以分为动态和静态两种动态创建数组（没有为元素赋值，可以结合for循环进行赋值） char[] chAry = new char[10]; 静态创建数组，在创建的时候，即为每个元素赋初值 int[] ary1 = new int[]{1, 2, 3, 4, 5}; 数组的长度数组的长度：length属性 int [] b1 = new int []{1,2,3,4,5,6,7}; System.out.println(b1.length); 注意：数组的长度是属性，String的长度是length（）；创建数组的时候必须指定数组的长度，而且一经定义则不允许改变。数组的长度虽然是7，但是在内存中实际给8个位置，另外一个存储7. 数组之间赋值在C语言中，不可以将数组直接赋值给另一个数组；

Java数组练习题(带答案)

一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。二选择题 1.下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B__ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是_D___ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 8.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() {

vc 创建动态数组

如何在VC中创建动态数组关键词：VC 动态数组怎样给多维数组动态分配内存 //Allocate: int **p = new int* [m]; for(int i = 0 ; i < m ; i++) p[i] = new int[n]; //Use: for(int i = 0 ; i < m; i++) for(int j = 0 ; j < n ; j++) p[i][j] = i * j; //Free: for(int i = 0 ; i < m ; i++) delete[] p[i]; delete[] p; 1. 演示形为int[2][3]的二维动态数组 /////////////////////////////////////////////////////////////////// int n1, n2; const int DIM1 = 2; const int DIM2 = 3; // 构造数组 int **ppi = new int*[DIM1]; for(n1 = 0; n1 < DIM1; n1++) { ppi[n1] = new int[DIM2]; } // 填充数据 for(n1 = 0; n1 < DIM1; n1++) { for(n2 = 0; n2 < DIM2; n2++) { ppi[n1][n2] = n1 * 10 + n2; } } // 输出 for(n1 = 0; n1 < DIM1; n1++) { for(n2 = 0; n2 < DIM2; n2++) { afxDump << "ppi[" << n1 << "][" << n2 << "] = " << ppi[n1][n2] << "\n"; } }

一维动态数组

用动态内存分配方法设计一个数组类，实现排序、插入等基本功能（特别注意拷贝构造函数的写法）#pragma once #include using namespace std; class myArrayList { public: myArrayList(int n=0); myArrayList(const int *a,int n); myArrayList(const int *a,int n,int max); myArrayList(const myArrayList &tList); ~myArrayList(void); void sort(); void show(); bool orderInsert(int num); private: int maxLen; int Len; int *arrPtr; }; #include"myArrayList.h" myArrayList::myArrayList(int n) { this->arrPtr=NULL; maxLen=Len=0; } myArrayList::~myArrayList(void) { delete [] arrPtr; } myArrayList::myArrayList(const int a[], int n) { maxLen=Len=n; this->arrPtr=new int[maxLen]; for(int i=0;iarrPtr=new int[maxLen];

JAVA数组与List之间相互转换的方法详解

数组与List之间相互转换的方法详解 1.List转换成为数组。（这里的List是实体是ArrayList) 调用ArrayList的toArray方法。 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"); finalint 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.打印结果如下：复制代码代码如下: 1 2 [[I@dc8569] [a, b, c] 下面说说Arrays.asList()的返回值： JDK文档是这么说的： public static ListasList(T... a) 返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同Collection.toArray() 一起，充当了基于数组的API 与基于collection 的API 之间的桥梁。返回的列表是可序列化的，并且实现了RandomAccess。此方法还提供了一个创建固定长度的列表的便捷方法，该列复制代码代码如下:

Java数组与方法

若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 3.1 一维数组一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。可以将它简单的理解为是相同数据类型的数据的集合。 3.1.1 一维数组的声明与内存的分配要使用Java的数组，必须经过两个步骤：（1）声明数组（2）给数组分配内存这两个步骤的语法如下：数据类型数组名[ ]; 或数据类型[ ] 数组名; // 声明一维数组数组名= new 数据类型[个数]; // 给数组分配内存数组的声明格式里，“数据类型”是声明数组每个元素的数据类型，常见的类型有整型、浮点型与字符型等，也可以是引用类型。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议使用有意义的名称为数组命名。数组声明后，接下来便是要配置数组所需的内存，其中“个数”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的个数，在内存中开辟一块内存供该数组使用。需要注意的是，在Java中声明数组的时候，不能在[]中指定其长度。比如：int score[3]; // 错误下面是关于一维数组的声明并分配内存给该数组的一个范例： int score[]; // 声明整型数组score score = new int[3]; // 为整型数组score分配内存空间，其元素个数为3 在上例中的第一行，当声明一个整型数组score时，score可视为数组类型的变量，此时这个变量并没有包含任何内容，编译器仅会分配一块内存给它，用来保存指向数组实体的地址，如图3-1所示。图3-1 声明整型数组声明之后，接着要做内存分配的操作，也就是上例中第二行语句。这一行会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。其内存分配的流程如图3-2所示。

C语言动态数组

动态数组是指在声明时没有确定数组大小的数组，即忽略圆括号中的下标；当要用它时，可随时用ReDim语句（C语言中用malloc语句）重新指出数组的大小。使用动态数组的优点是可以根据用户需要，有效利用存储空间。动态数组，是相对于静态数组而言。静态数组的长度是预先定义好的，在整个程序中，一旦给定大小后就无法改变。而动态数组则不然，它可以随程序需要而重新指定大小。动态数组的内存空间是从堆（heap）上分配（即动态分配）的。是通过执行代码而为其分配存储空间。当程序执行到这些语句时，才为其分配。程序员自己负责释放内存。（欲详细了解堆请见堆栈）为什么要使用动态数组？在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。对于这种问题，用静态数组的办法很难解决。为了解决上述问题，C语言提供了一些内存管理函数，这些内存管理函数结合指针可以按需要动态地分配内存空间，来构建动态数组，也可把不再使用的空间回收待用，为有效地利用内存资源提供了手段。动态数组与静态数组的对比对于静态数组，其创建非常方便，使用完也无需释放，要引用也简单，但是创建后无法改变其大小是其致命弱点！对于动态数组，其创建麻烦，使用完必须由程序员自己释放，否则严重会引起内存泄露。但其使用非常灵活，能根据程序需要动态分配大小。如何构建动态数组遵循原则申请的时候从外层往里层，逐层申请；释放的时候从里层往外层，逐层释放。构建所需指针对于构建一维动态数组，需要一维指针；对于二维，则需要一维，二维指针；三维需要一，二，三维指针；依此类推。构建所需函数函数原型返回功能说明 void *malloc(unsigned int size); 成功：返回所开辟空间首地址失败：返回空指针向系统申请size字节的堆空间 void *calloc(unsigned int num, unsigned int size);成功：返回所开辟空间首地址失败：返回空指针按类型申请num个size字节的堆空间 void free(void *p); 无返回值释放p指向的堆空间 void *realloc(void *p,unsigned int size); 成功：返回新开辟空间首地址失败：返回空指针将p指向的堆空间变为size 说明：（1）规定为void *类型，这并不是说该函数调用后无返回值，而是返回一个结点的地址，该地址的类型为void(无类型或类型不确定）,即一段存储区的首址，其具体类型无法确定，只有使用时根据各个域值数据再确定。可以用强制转换的方法将其转换为别的类型。例