集合1--毕向东java基础教程视频学习笔记

Day14 集合框架
01 体系概述
02 共性方法
03 迭代器
04 List集合共性方法
05 ListIterator
06 List集合具体对象特点
07 Vector中的枚举

 

01 体系概述

集合类
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就需要对对象进行存储。
集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的，集合的长度是可变的。
数组中可以存储进本数据类型，集合只能存储对象。
集合类的特点：
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

02 共性方法

1.add方法的参数是object类型，以便与接受任意类型对象。
2.集合中存储的都是对象的引用（地址）。

 1 import java.util.*;
 2 class  CollectionDemo
 3 {
 4     public static void main(String[] args) 
 5     {
 6         method();
 7         base_Method();
 8         
 9 
10     }
11     //求交集
12     public static void method()
13     {
14         ArrayList al=new ArrayList();
15         al.add("java01");
16         al.add("java02");
17         al.add("java03");
18         al.add("java04");
19         sop("al原集合"+al);
20 
21         ArrayList al2=new ArrayList();
22         al2.add("java01");
23         al2.add("java07");
24         al2.add("java03");
25         al2.add("java08");
26         sop("al2原集合"+al2);
27 
28         al.retainAll(al2);
29         sop("al求交后的集合"+al);
30 
31 
32     }
33     public static void base_Method()
34     {
35         //创建一个集合容器，使用Collection接口的子类，ArrayList
36         ArrayList al=new ArrayList();
37         
38 
39         //1.添加元素
40         al.add("java01");
41         al.add("java02");
42         al.add("java03");
43         al.add("java04");
44 
45         //打印集合
46         sop("原集合："+al);
47         //2.删除元素
48         al.remove("java02");
49         sop("改变后的集合："+al);
50         //al.clear();
51 
52         //4.判断元素
53         sop("java03是否存在"+al.contains("java03"));
54         sop("集合是否为空"+al.isEmpty());
55 
56         //获取集合长度
57         sop("size:"+al.size());
58     }
59     public static void sop(Object obj)
60     {
61         System.out.println(obj);
62     }
63 }

View Code

 

03 迭代器

什么是迭代器？
其实就是集合中取出元素的方式。

把取出方式定义在集合的内部。
这样取出方式就可以直接访问集合内部的元素。
那么取出方式被定义为内部类。
每一个容器的数据结构不同，
取出的动作细节不一样，但都有共性的内容
判断和取出，那么可以将共性抽取。

这些内部类都符合一个规则。该规则是Iterator.
如何获取集合的取出对象呢？
通过一个对外提供的方法
iterator();

 1 import java.util.*;
 2 class  CollectionDemo
 3 {
 4     public static void main(String[] args) 
 5     {
 6         method();
 7 
 8     }
 9     //求交集
10     public static void method()
11     {
12         ArrayList al=new ArrayList();
13         al.add("java01");
14         al.add("java02");
15         al.add("java03");
16         al.add("java04");
17         
18         //获取迭代器，用于取出集合中的元素
19         /*Iterator it=al.iterator();
20 
21         while(it.hasNext())
22         {
23             sop(it.next());
24         }
25         */
26         for(Iterator it=al.iterator();it.hasNext();)
27         {
28             sop(it.next());
29         }
30 
31     }
32 
33     public static void sop(Object obj)
34     {
35         System.out.println(obj);
36     }
37 }

View Code

 

04 List集合共性方法

Collection
|--List:元素是有序的，元素可以重复。因为该集合有索引。
|--Set：元素是无序的，元素不可以重复。

List:
凡是可以操作角标的方法都是该体系的特有方法

增：add(index,element)
addAll(index,Collection)

删：remove(index)

改：set(index,element)

查：get(index)
subList(from,to)
listIterator();

 1 import java.util.*;
 2 class ListDemo 
 3 {
 4     public static void sop(Object obj)
 5     {
 6         System.out.println(obj);
 7     }
 8     public static void main(String[] args) 
 9     {
10         ArrayList al=new ArrayList();
11         al.add("java01");
12         al.add("java02");
13         al.add("java03");
14         sop("原集合："+al);
15 
16         //在指定位置添加元素
17         al.add(1,"java09");
18         sop("改变后集合："+al);
19 
20         //删除指定位置的元素
21         //al.remove(2);
22 
23         //修改元素
24         al.set(2,"java07");
25         //sop(al);
26 
27         //通过角标获取元素
28         sop("get(i)"+al.get(1));
29 
30         //获取所有元素
31         for(int x=0;x)
32         {
33             System.out.println("al("+x+")="+al.get(x));
34         }
35 
36         
37         for(Iterator it=al.iterator();it.hasNext();)
38         {
39             sop("next:"+it.next());
40         }
41 
42     }
43 }

View Code

 

05 ListIterator

List集合特有的迭代器：ListIterator是Iterator的子接口。
在迭代时，不可以通过集合的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。

所以，在迭代时，只能用迭代器的方法操作元素，可是iterator方法是有限的
只能对元素进行判断，取出，删除
如果想要做其他的操作，如添加、修改等，就需要用到其子接口ListIterator

该接口只能通过List的ListIterator方法获取。

 1 import java.util.*;
 2 class ListDemo 
 3 {
 4     public static void sop(Object obj)
 5     {
 6         System.out.println(obj);
 7     }
 8     public static void main(String[] args) 
 9     {
10         ArrayList al=new ArrayList();
11         al.add("java01");
12         al.add("java02");
13         al.add("java03");
14         sop("原集合："+al);
15 
16         ListIterator li=al.listIterator();
17         //在迭代过程中，操作元素
18         while(li.hasNext())
19         {
20             Object obj=li.next();
21             if(obj.equals("java02"))
22                 li.set("java006");
23         }
24         sop("改变后集合："+al);
25 
26         //逆序输出
27         while(li.hasPrevious())
28         {
29             sop("pre:"+li.previous());
30 
31         }
32         sop(al);
33 
34     }
35 }

View Code

 

06 List集合具体对象特点

|--List:元素是有序的，元素可以重复。因为该集合有索引。
  |--ArrayList:底层的数据结构使用的数组结构。特点：查询速度很快，但是增删稍慢，元素越多，这点体现越明显。线程不同步。
  |--LinkedList:底层使用的是链表数据结构。 特点：增删快，查询速度很慢。
  |--Vector：底层是数组数据结构。它比ArrayList先出现。 线程同步。被ArrayList代替了。

07 Vector中的枚举

 1 /*
 2 枚举就是Vector特有的取出方式。
 3 发现枚举和迭代器很像。
 4 其实枚举和迭代是一样的。
 5 
 6 因为枚举的名称以及方法的名称都过长。
 7 所以被迭代器取代了。
 8 枚举郁郁而终。
 9 */
10 import java.util.*;
11 
12 class VectorDemo 
13 {
14     public static void main(String[] args) 
15     {
16         Vector v=new Vector();
17         
18         v.add("java01");
19         v.add("java02");
20         v.add("java03");
21         v.add("java04");
22 
23         Enumeration en=v.elements();
24 
25         while(en.hasMoreElements())
26         {
27             System.out.println(en.nextElement());
28         }
29 
30     }
31 }

 

转载于:https://www.cnblogs.com/wsw-tcsygrwfqd/p/5146788.html