list子类.docx
《list子类.docx》由会员分享，可在线阅读，更多相关《list子类.docx（16页珍藏版）》请在冰豆网上搜索。
list子类
13.3.2List接口的常用子类
13.3.2 List接口的常用子类
（1）
1．新的子类：
ArrayList
ArrayList是List子类，可以直接通过对象的多态性为List接口实例化。
此类的定义如下：
1.public class ArrayList extends AbstractList
2.implements List, RandomAccess, Cloneable, Serializable
从定义中可以发现ArrayList类继承了AbstractList类。
AbstractList类的定义如下：
1.public abstract class AbstractList
2.extends AbstractCollection implements List
此类实现了List接口，所以可以直接使用ArrayList为List接口实例化。
下面通过一些实例操作为读者讲解List接口中主要方法的使用。
（1）实例操作一：
向集合中增加元素
要想完成此类操作，可以直接使用Collection接口中定义的两个方法。
增加一个元素：
publicbooleanadd（Eo）。
增加一组元素：
publicbooleanaddAll（Collection
extendsE>c）。
也可以使用List扩充的add（）方法在指定位置处增加元素。
在指定位置处添加元素：
publicvoidadd（intindex,Eelement）。
范例：
验证增加数据的操作
1.package org.lxh.demo13.listdemo;
2.import java.util.ArrayList;
3.import java.util.Collection;
4.import java.util.List;
5.public class ArrayListDemo01 {
6. public static void main（String[] args） {
7. List allList = null ;
// 定义List对象
8. Collection allCollection = null ;
// 定义Collection对象
9. allList = new ArrayList（）;
10. // 实例化List对象，只能是
11.String类型
12. allCollection = new ArrayList（）;
13.// 实例化Collection，只能
14.是String类型
15. allList.add（"Hello"）;
16. // 从Collection继承的方法
17. allList.add（0, "World"）;
// 此方法为List扩充的方法
18. System.out.println（allList）;
// 输出集合中的内容
19. allCollection.add（"LXH"）;
// 增加数据
20. allCollection.add（""）;
// 增加数据
21. allList.addAll（allCollection）;
// 从Collection继承的方
22.法，增加一组对象
23. allList.addAll（0, allCollection）;
// 此方法是List自定义的，
24.增加一组对象
25. System.out.println（allList）;
26. // 输出对象，调用
27.toString（）方法
28. }
29.}
程序运行结果：
1.[World, Hello]
2.[LXH, , World, Hello, MLDN, ]
从程序的运行结果中可以发现，使用List中的add（intindex,Eelement）方法可以在集合中的指定位置增加元素，而其他的两个add（）方法只是在集合的最后进行内容的追加。
13.3.2 List接口的常用子类
（2）
（2）实例操作二：
删除元素
在类集中提供了专门的删除元素的方法，Collection和List接口都分别定义了删除数据的方法。
Collection定义的方法
每次删除一个对象：
publicbooleanremove（Objecto）。
每次删除一组对象：
publicbooleanremoveAll（Collection
>c）。
List扩展的方法
删除指定位置的元素：
publicEremove（intindex）。
范例：
删除对象
1.package org.lxh.demo13.listdemo;
2.import java.util.ArrayList;
3.import java.util.List;
4.public class ArrayListDemo02 {
5. public static void main（String[] args） {
6. List allList = null ;
// 声明List对象
7. allList = new ArrayList（）;
8.// 实例化List对象，只能是String
9.类型
10. allList.add（"Hello"）;
11. // 增加元素
12. allList.add（0, "World"）;
// 此方法为List扩展的增加方法
13. allList.add（"MLDN"）;
14. // 增加元素
15. allList.add（""）;
// 增加元素
16. allList.remove（0）;
// 删除指定位置的元素
17. allList.remove（"Hello"）;
// 删除指定内容的元素
18. System.out.println（allList）;
19. // 输出对象，调用toString（）方法
20. }
21.}
程序运行结果：
1.[MLDN, ]
在集合中增加完数据后，可以通过下标或对象的方式直接对集合中的元素进行删除。
U提示：
关于使用remove（Objecto）方法删除对象的说明。
在集合中可以插入任意类型的对象，在本程序中是以String类的对象为例，所以在使用remove（Objecto）方法删除时可以直接删除；而对于自定义的类如果要通过此种方式删除，则必须在类中覆写Object类的equals（）及hashCode（）方法。
这两个方法的使用在随后的章节中将为读者介绍。
（3）实例操作三：
输出List中的内容
在Collection接口中定义了取得全部数据长度的方法size（），而在List接口中存在取得集合中指定位置元素的操作get（intindex），使用这两个方法即可输出集合中的全部内容。
范例：
输出全部元素
1.package org.lxh.demo13.listdemo;
2.import java.util.ArrayList;
3.import java.util.List;
4.public class ArrayListDemo03 {
5. public static void main（String[] args） {
6. List allList = null ;
// 定义List接口对象
7. allList = new ArrayList（）;
8. // 实例化List对象，只
9.能是String类型
10. allList.add（"Hello"）;
11. // 增加元素
12. allList.add（"Hello"）;
13. // 增加元素
14. allList.add（0, "World"）;
// 增加元素
15. allList.add（"MLDN"）;
16. // 增加元素
17. allList.add（""）;
// 增加元素
18. System.out.print（"由前向后输出：
"）;
// 信息输出
19. for （int i = 0; i < allList.size（）; i++） {
// 循环输出集合内容
20. System.out.print（allList.get（i） + "、"）;
// 通过下标取得集合中
21.的元素
22. }
23. System.out.print（"\n由后向前输出：
"）;
24. for （int i = allList.size（） - 1; i >=
0; i--） {// 循环输出集合内容
25. System.out.print（allList.get（i） +
"、"）; // 通过下标取得集合中
26.的元素
27. }
28. }
29.}
程序运行结果：
1.由前向后输出：
World、Hello、Hello、MLDN、、
2.由后向前输出：
、MLDN、Hello、Hello、World、
从程序的运行结果中可以看出，在List集合中数据增加的顺序就是输出后的顺序，本身顺序不会发生改变。
（4）实例操作四：
将集合变为对象数组
在Collection中定义了toArray（）方法，此方法可以将集合变为对象数组，但是由于在类集声明时已经通过泛型指定了集合中的元素类型，所以在接收时要使用泛型指定的类型。
范例：
将集合变为对象数组
1.package org.lxh.demo13.listdemo;
2.import java.util.ArrayList;
3.import java.util.List;
4.public class ArrayListDemo04 {
5. public static void main（String[] args） {
6. List allList = null ;
// 声明List对象
7. allList = new ArrayList（）;
8. // 实例化List对象，只能是
9.String类型
10. allList.add（"Hello"）;
11. // 增加元素
12. allList.add（0, "World"）;
// 增加元素
13. allList.add（"MLDN"）;
14. // 增加元素
15. allList.add（""）; // 增加元素
16. String str[] = allList.toArray（new String[]
{}）; // 指定的泛型类型
17. System.out.print（"指定数组类型：
"）;
// 信息输出
18. for （int i = 0; i < str.length; i++） {
// 输出字符串数组中的内容
19. System.out.print（str[i] + "、"）;
// 输出每一个元素
20. }
21. System.out.print（"\n返回对象数组：
"）;
// 信息输出
22. Object obj[] = allList.toArray（）;
// 直接返回对象数组
23. for （int i = 0; i < obj.length; i++） {
// 循环输出对象数组内容
24. String temp = （String） obj[i];
// 每一个对象都是String类
25.型实例
26. System.out.print（temp + "、"）;
// 输出每一个元素
27. }
28. }
29.}
程序运行结果：
1.指定数组类型：
World、Hello、MLDN、、
2.返回对象数组：
World、Hello、MLDN、、
13.3.2 List接口的常用子类（3）
（5）实例操作五：
集合的其他相关操作
在List中还存在截取集合、查找元素位置、判断元素是否存在、集合是否为空等操作。
下面直接测试以上的操作。
范例：
测试其他操作
1.package org.lxh.demo13.listdemo;
2.import java.util.ArrayList;
3.import java.util.List;
4.public class ArrayListDemo05 {
5. public static void main（String[] args） {
6. List allList = null ;
// 声明List对象
7. allList = new ArrayList（）;
8. // 实例化List对象，只能是
9.String类型
10. System.out.println（"集合操作前是否为空？
"
+ allList.isEmpty（））;
11. allList.add（"Hello"）;
12. // 增加元素
13. allList.add（0, "World"）;
// 增加元素
14. allList.add（"MLDN"）;
15. // 增加元素
16. allList.add（""）;
// 增加元素
17. System.out.println（allList.contains（"Hello"） ?
18. "\"Hello\"字符串存在！
":
"\"Hello\"字符串不存在！
"）;
19. List allSub = allList.subList（2,
3）;// 取出里面的部分集合
20. System.out.print（"集合截取：
"）;
21. for （int i = 0; i < allSub.size（）; i++） {
// 截取部分集合
22. System.out.print（allList.get（i） + "、"）;
23. }
24. System.out.println（""） ;
25. System.out.println（"MLDN字符串的位置：
" + allList.indexOf（"MLDN"））;
26. System.out.println（"集合操作后是否为空？
" + allList.isEmpty（））;
27. }
28.}
程序运行结果：
1.集合操作前是否为空？
true
2."Hello"字符串存在！
3.集合截取：
World、
4.MLDN字符串的位置：
2
5.集合操作后是否为空？
false
List集合在刚刚实例化之后因为还有为其增加内容，所以在使用isEmpty（）方法时返回的结果是true，表示集合是空的，之后向集合中增加了4个元素，所以程序的最后再使用此方法判断时就返回false，表示集合中已经存在内容。
在程序中使用contains（）方法判断集合中是否存在指定的元素，如果存在，则输出存在的信息；反之，输出不存在的信息。
在集合中也可以使用subList（）方法取出指定的子集合。
2．挽救的子类：
Vector
在List接口中还有一个子类Vector，Vector类属于一个挽救的子类，从整个Java的集合发展历史来看，Vector算是一个元老级的类，在JDK1.0时就已经存在此类。
到了Java2（JDK1.2）之后重点强调了集合框架的概念，所以先后定义了很多的新接口（如List等），但是考虑到一大部分用户已经习惯了使用Vector类，所以Java的设计者就让Vector类多实现了一个List接口，这才将其保留下来。
但是因为其是List子类，所以Vector类的使用与之前的并没有太大的区别。
Vector类的定义如下：
1.public class Vector extends AbstractList
2.implements List, RandomAccess, Cloneable, Serializable
从Vector类的定义中可以发现，此类与ArrayList类一样也继承自AbstractList类。
范例：
Vector子类
1.import java.util.List;
2.import java.util.Vector;
3.public class VectorDemo01 {
4. public static void main（String[] args） {
5. List allList = null ;
// 声明List对象
6. allList = new Vector（）;
7. // 实例化List对象，只
8.能是String类型
9. allList.add（"Hello"）;
10. // 增加元素
11. allList.add（0, "World"）;
// 增加元素
12. allList.add（"MLDN"）;
// 增加元素
13. allList.add（""）;
// 增加元素
14. for （int i = 0; i < allList.size（）; i++） {
// 循环输出
15. System.out.print（allList.get（i） + "、"）;
// 通过get（）取出每一
16.个元素
17. }
18. }
19.}
程序运行结果：
1.World、Hello、MLDN、、
如果直接使用的是List接口进行操作，则在运行结果上与ArrayList本身没有任何的区别，但是因为Vector类出现较早，所以也定义了许多在List接口中没有定义的方法，这些方法的功能与List类似。
例如，Vector类中的addElement（Eo）方法，是最早的向集合中增加元素的操作，但是在JDK1.2之后此方法的功能与List接口中add（Eo）方法是一致的。
范例：
使用旧的方法
1.package org.lxh.demo13.listdemo;
2.import java.util.Vector;
3.public class VectorDemo02 {
4. public static void main（String[] args） {
5. Vector allList = new Vector（）;
// 实例化Vector对象
6. allList.addElement（"Hello"）;
7. // 此方法为Vector自
8.己定
升级会员 