java有序列表
1. java中的linklist有哪些用法，list.add,list.getFirst(),这些是什么意思
ArrayList Vector LinkedList 区别与用法
ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！
线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
Iterator it = collection.iterator(); // 获得一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}
由Collection接口派生的两个接口是List和Set。
List接口
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。
LinkedList类
LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样，ArrayList也是异步的（unsynchronized）。
Vector类
Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出，因此必须捕获该异常。
Stack 类
Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
Map接口
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。
Hashtable类
Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一个数，比如2，用相应的key：
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
Hashtable是同步的。
HashMap类
HashMap和Hashtable类似，不同之处在于HashMap是异步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
WeakHashMap类
WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。
总结
如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑异步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。
同步性
Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。
数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。
使用模式
在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。
最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。
2. java 创建方法合并两个有序链表成一个新的有序链表 代码
public static SortedList mergeList(SortedList list1, SortedList list2){
Link current = list2.first;
while(current != null){
list1.insert(current.dData);
current = current.next;
}
return list1;
}
3. java有哪些集合
Java集合主要有四种，分别为：List列表、Queue队列、Set集合、Map映射。
List列表：有序的，可重复的;
Queue队列：有序，可重复的;
Set集合：不可重复;
Map映射：无序，键唯一，值不唯一。
4. 如何用java设计一个有序单链表类
class SortedLink{
public Node head;
public int add(Node assigned , Node input){
Node temp=head;
while(temp.next!=null){
if(temp==assigned) {
Node t=assigned.next;
assigned.next=input;
input.next=t;
return 1;
}
temp=temp.next;
}
return 0;
}
public int remove(Node assigned){
Node temp1=head;
Node temp2=head.next;
while(temp2.next!=null){
if(temp2==assigned) {
temp1.next=temp2.next;
temp2.dispose();
return 1;
}
temp1=temp2;
temp2=temp2.next;
}
return 0;
}
}
Node是一个类，就自己实现吧……
5. 请大侠简要的给我说一下java中list,hashmap的联系和区别，不胜感激！
从帮助文档看
List
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素
hashmap
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
－－－－－－－－－－－－－－－－－－－－－－
说白了点，两者都是集合，list是有序的，通过其实现的类看出来，如ArrayList，Vector 等。其取值是通过索引，如get（1）方法;hashmap是无序的，取值通过关键字key 取得 get（"key"）其接口是map
－－－－－－－－－－－－－－－－－－－－
从你的提问说明下，而这区别还存在 list 是接口interface hashmap是类class，弄清楚接口和类的区别
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
6. java有哪些有序集合
1、List：有序的collection（也称为序列）。此接口可以对列表中每个元素的插入位置进行精确地控制。可以根据元素的在列表中的位置访问元素，并搜索列表中的元素。列表允许重复的元素。
ArrayList:
特点：有序的、线性的、无固定大小的、有下标的、先进先出。
2.Set:是简单的集合，它的对象不按特定方式排序，只是简单的把对象加入集合中。不能有重复对象。
HashSet:
特点：无序的，长度可变的，不可重复的。
3.Map:Map中存入的对象是一对一对的，即每个对象和它的一个名字（键：key）关联在一起，一个键（key）只能对应一个值（value）,反则不然。
HashMap:
特点：无序的、不可重复的。
7. java arraylist是有序的吗
是有序的。
比如：List<Integer> list=new ArrayList<Integer>();
list.get(0)
一个list，第一个放进去是1，第二个放进去是2：
List<Integer> numList=new ArrayList<>();
numList.add(1);
numList.add(2);
当取第一个时numList.get(0)；(下标从0开始)
打印它出来还是：1
(7)java有序列表扩展阅读：
LinkedList ：对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢。(使用ArrayList代替)还具有下列方 法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast()， 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
8. java中list，set和map 的区别
List有序列表，除了首尾，每一项都有前趋后继项。
Set无序集。
Map是Key＞Value映射的集合。
9. Java中二维数组排序的问题
文章
java数组排序2009年09月12日 星期六 下午 12:55import java.util.Random;
/**
* 排序测试类
*
* 排序算法的分类如下：
* 1.插入排序（直接插入排序、折半插入排序、希尔排序）；
* 2.交换排序（冒泡泡排序、快速排序）；
* 3.选择排序（直接选择排序、堆排序）；
* 4.归并排序；
* 5.基数排序。
*
* 关于排序方法的选择：
* (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
* 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
* (2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
* (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
*
* @author WangRuifeng
*/
public class SortTest {
/**
* 初始化测试数组的方法
* @return 一个初始化好的数组
*/
public int[] createArray() {
Random random = new Random();
int[] array = new int[10];
for (int i = 0; i < 10; i++) {
array[i] = random.nextInt(100) - random.nextInt(100);//生成两个随机数相减，保证生成的数中有负数
}
System.out.println("==========原始序列==========");
printArray(array);
return array;
}
/**
* 打印数组中的元素到控制台
* @param source
*/
public void printArray(int[] source) {
for (int i : source) {
System.out.print(i + " ");
}
System.out.println();
}
/**
* 交换数组中指定的两元素的位置
* @param source
* @param x
* @param y
*/
private void swap(int[] source, int x, int y) {
int temp = source[x];
source[x] = source[y];
source[y] = temp;
}
/**
* 冒泡排序----交换排序的一种
* 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。
* 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
*
* @param source 要排序的数组
* @param sortType 排序类型
* @return
*/
public void bubbleSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
for (int i = source.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (source[j] > source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
for (int i = source.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (source[j] < source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(source);//输出冒泡排序后的数组值
}
/**
* 直接选择排序法----选择排序的一种
* 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
* 性能：比较次数O(n^2),n^2/2
* 交换次数O(n),n
* 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
* 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
*
* @param source 要排序的数组
* @param sortType 排序类型
* @return
*/
public void selectSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] > source[j]) {
swap(source, i, j);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] < source[j]) {
swap(source, i, j);
}
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(source);//输出直接选择排序后的数组值
}
/**
* 插入排序
* 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。
* 性能：比较次数O(n^2),n^2/4
* 复制次数O(n),n^2/4
* 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
*
* @param source 要排序的数组
* @param sortType 排序类型
*/
public void insertSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] < source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] > source[j - 1]); j--) {
swap(source, j, j - 1);
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(source);//输出插入排序后的数组值
}
/**
* 反转数组的方法
* @param source 源数组
*/
public void reverse(int[] source) {
int length = source.length;
int temp = 0;//临时变量
for (int i = 0; i < length / 2; i++) {
temp = source[i];
source[i] = source[length - 1 - i];
source[length - 1 - i] = temp;
}
printArray(source);//输出到转后数组的值
}
/**
* 快速排序
* 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
* 步骤为：
* 1. 从数列中挑出一个元素，称为 "基准"（pivot），
* 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
* 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
* 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
* @param source 待排序的数组
* @param low
* @param high
* @see SortTest#qsort(int[], int, int)
* @see SortTest#qsort_desc(int[], int, int)
*/
public void quickSort(int[] source, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
qsort_asc(source, 0, source.length - 1);
} else if (sortType.equals("desc")) { //倒排序，从大排到小
qsort_desc(source, 0, source.length - 1);
} else {
System.out.println("您输入的排序类型错误！");
}
}
/**
* 快速排序的具体实现，排正序
* @param source
* @param low
* @param high
*/
private void qsort_asc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //这个条件用来结束递归
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] > x) {
j--; //从右向左找第一个小于x的数
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] < x) {
i++; //从左向右找第一个大于x的数
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
qsort_asc(source, low, i - 1);
qsort_asc(source, i + 1, high);
}
}
/**
* 快速排序的具体实现，排倒序
* @param source
* @param low
* @param high
*/
private void qsort_desc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //这个条件用来结束递归
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] < x) {
j--; //从右向左找第一个小于x的数
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] > x) {
i++; //从左向右找第一个大于x的数
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
qsort_desc(source, low, i - 1);
qsort_desc(source, i + 1, high);
}
}
/**
* 二分法查找
* 查找线性表必须是有序列表
*
* @param source
* @param key
* @return
*/
public int binarySearch(int[] source, int key) {
int low = 0, high = source.length - 1, mid;
while (low <= high) {
mid = (low + high) >>> 1; //相当于mid = (low + high) / 2，但是效率会高些
if (key == source[mid]) {
return mid;
} else if (key < source[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}
public static void main(String[] args) {
SortTest sortTest = new SortTest();
int[] array = sortTest.createArray();
System.out.println("==========冒泡排序后(正序)==========");
sortTest.bubbleSort(array, "asc");
System.out.println("==========冒泡排序后(倒序)==========");
sortTest.bubbleSort(array, "desc");
array = sortTest.createArray();
System.out.println("==========倒转数组后==========");
sortTest.reverse(array);
array = sortTest.createArray();
System.out.println("==========选择排序后(正序)==========");
sortTest.selectSort(array, "asc");
System.out.println("==========选择排序后(倒序)==========");
sortTest.selectSort(array, "desc");
array = sortTest.createArray();
System.out.println("==========插入排序后(正序)==========");
sortTest.insertSort(array, "asc");
System.out.println("==========插入排序后(倒序)==========");
sortTest.insertSort(array, "desc");
array = sortTest.createArray();
System.out.println("==========快速排序后(正序)==========");
sortTest.quickSort(array, "asc");
sortTest.printArray(array);
System.out.println("==========快速排序后(倒序)==========");
sortTest.quickSort(array, "desc");
sortTest.printArray(array);
System.out.println("==========数组二分查找==========");
System.out.println("您要找的数在第" + sortTest.binarySearch(array, 74) + "个位子。（下标从0计算）");
}
}
字符串排序：
public class StringSort {
public static void main(String []args) {
String[] s={"a","b","c","d","m","f"};
for(int i=s.length-1;i>=1;i--){
for(int j=0;j<=i-1;j++) {
if(s[j].compareTo(s[j+1])<0) {
String temp=null;
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
for(String a:s){
System.out.print(a+" ");
}
}
}
比较字符串的实质是比较字符串的字母，首字母相同，比较下一个，然后又相同的话，再下一个....所以你可以先用substring();截出第一个字符，然后再比较，相同的再截第二个，.....
hope some help for you
10. java里 list顺序是固定的吗,是有序的吗
list是有序的,是以数组的存储方式进行存储.也就是说数组什么样它就什么样,唯一的区别就是,它没有固定大小. 且list的检索效率比较高,不过要频繁的对这个容器里的元素进行更新就不要用它了,用linkedlist比较好.
顺序放进去是不会乱的，举个例子，一个list，第一个放进去是1，第二个放进去是2：
List<Integer> numList=new ArrayList<>();
numList.add(1);
numList.add(2);
当你取第一个时numList.get(0)；(下标从0开始)
打印它出来还是：1
List 接口下ArrayList 特点是: 插入数据 有序且可重复 适合查找多增删少。