------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
集合（1）
主要内容：《 数组的局限性、Collection接口的结构和基本方法、批量操作、遍历、迭代器、list接口、list接口方法、ArrayList、Vector 》
1.数组的局限性
当我们面向对象编程时，总要处理大量的对象；
1.处理大量对象，可以使用"数组"存储；
2.但数组有很多的局限性：
1).数组的长度一旦确定，后期不能更改；我们程序员可以定义新的数组，但是每次做这样的操作都很费事；
2).数组在定义时，指定了"数据类型"，那么这个数组就只能装这个数据类型的，不能装其它类型的。
3.以上的两个局限性，对于我们程序员来说，在操作大量对象时，就非常的不方便。 所以这时，Java为我们提供了一种"工具"。它类似于"仓库"，可以用来存 储大量的"引用"。
这种"仓库"就是："集合类"；
特点：
1).对于我们程序员来说，就像一个"无底洞"，可以装无数的"引用"；我们不用关心"长度"信息；
2).这些"集合类"可以装任何"引用数据"类型的数据；
2.Collection接口的结构
3.Collection接口的基本方法
1.添加：
boolean add(Object e):将元素e的引用添加到集合中；如果此 collection 由于调用而发生更改，则返回 true。（
2.删除
boolean remove(Object o):将元素o从集合中删除。删除第一个匹配的元素，之后就返回；
void clear():清空集合
3.获取：
boolean contains(Object o)：查找集合中的元素o，如果有：返回true，否则返回false;内部使用equals()进行判断；
boolean isEmpty():判断集合是否为空:
int size()：获取集合的大小；
使用子类：ArrayList
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 Collection list = new ArrayList();
5 //2.boolean add(Object e)：填充集合
6 System.out.println(list.add("刘德华"));
7 System.out.println(list.add("刘德华"));
8 System.out.println(list.add("张学友"));
9 System.out.println(list.add("刘亦菲"));
10 System.out.println("打印集合：" + list);
11
12 //3.boolean remove(Object o):将元素o从集合中删除
13 //从集合中移除"张学友"
14 /*
15 list.remove("张学友");//内部使用：equals()方法进行逐个判断。如果为true，则认为是相同元素，就执行删除
16 System.out.println("移除张学友后，打印集合：" + list);
17 */
18 /*
19 list.remove("刘德华");
20 System.out.println("移除1刘德华后，打印集合：" + list);
21 list.remove("刘德华");
22 System.out.println("移除2刘德华后，打印集合：" + list);
23 */
24 //4.void clear()
25 /*
26 list.clear();
27 System.out.println("清空集合后，打印集合：" + list);
28 */
29 //5.boolean contains(Object o)：查找集合中的元素o，如果有：返回true，否则返回false;
30 //在集合中查找"刘德华"
31 System.out.println("集合中是否存在刘德华:" + list.contains("刘德华"));//true
32 System.out.println("集合中是否存在范冰冰:" + list.contains("范冰冰"));//false
33 //6.boolean isEmpty():判断集合是否为空:
34 System.out.println("集合是否为空：" + list.isEmpty());
35 System.out.println("集合大小：" + list.size());
36 list.clear();
37 System.out.println("清空集合后，集合是否为空：" + list.isEmpty());
38 System.out.println("清空集合后，集合大小：" + list.size());
39 }
40 }
4.Collection的一些批量操作的方法：
boolean addAll(Collection c)：将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 * boolean removeAll(Collection c):移除此collection 中那些也包含在参数collection 中的所有元素（可选操作）。
boolean containsAll(Collection c):如果此 collection 包含指定 collection 中的"所有元素"，则返回 true。
boolean retainAll(Collection c):移除此 collection 中未包含在指定 collection 中的所有元素。
1 public class Demo {
2 public static void main(String[] args) {
3 //定义两个集合
4 Collection list1 = new ArrayList();
5 list1.add("刘德华");
6 list1.add("张学友");
7 list1.add("刘亦菲");
8
9 Collection list2 = new ArrayList();
10 list2.add("马云");
11 list2.add("柳传志");
12 list2.add("马化腾");
13
14
15 //1.boolean addAll(Collection c)
16 /*
17 list1.addAll(list2);
18 System.out.println(list1);
19 System.out.println(list2);
20 */
21 //2.boolean removeAll(Collection c)
22 /*
23 list1.removeAll(list2);
24 System.out.println("list1 = " + list1);
25 System.out.println("list2 = " + list2);
26 */
27 //3.boolean containsAll(Collection c)
28 /*
29 System.out.println(list1.containsAll(list2));
30 */
31 //4.boolean retainAll(Collection c)
32 list1.retainAll(list2);
33 System.out.println("list1 = " + list1);
34 System.out.println("list2 = " + list2.toString());
35 }
36 }
5.collection的遍历
1 public class Demo {
2 public static void main(String[] args) {
3 //1.定义集合
4 Collection list = new ArrayList();
5 //2.填充集合
6 list.add("刘德华");
7 list.add("张学友");
8 list.add("郭富城");
9 list.add("黎明");
10
11 //3.遍历集合
12 // System.out.println(list);//这不是遍历，是获取一个String
13 Object[] objArray = list.toArray();
14 for(int i = 0 ;i < objArray.length ; i++){
15 String s = (String)objArray[i];
16 System.out.println(s);
17 // System.out.println(objArray[i]);//调用Object-->toString()
18 }
19 }
20 }
6.Collection存储自定义对象
1 import java.util.ArrayList;
2 import java.util.Collection;
3
4 public class Demo {
5 public static void main(String[] args) {
6 //1.定义集合
7 Collection list = new ArrayList();
8 //2.填充集合
9 /*
10 Cat c1 = new Cat("波斯猫",2,‘雌‘);
11 list.add(c1);
12 */
13 list.add(new Cat("波斯猫",2,‘雌‘));
14 list.add(new Cat("折耳猫",3,‘雄‘));
15 list.add(new Cat("熊猫",4,‘雌‘));
16 list.add(new Cat("大脸猫",2,‘雄‘));
17
18 //3.遍历集合
19 Object[] objArray = list.toArray();
20 for(int i = 0 ;i < objArray.length ; i++){
21 Cat c = (Cat)objArray[i];
22 System.out.println(c.getName() + "," + c.getAge() + "," + c.getSex());
23 }
24
25 }
7.Collection遍历集合_迭代器
Collection集合的遍历方式二：
迭代器：
Iterator iterator():
java.util.Iterator(接口):
成员方法：
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
Object next() 返回迭代的下一个元素。
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合类；
4 Collection list = new ArrayList();
5 //2.填充集合
6 list.add("张三");
7 list.add("李四");
8 list.add("王五");
9 list.add("周六");
10 //3.使用迭代器遍历
11 Iterator it = list.iterator();
12 /*
13 Object obj = it.next();
14 System.out.println(obj);
15 obj = it.next();
16 System.out.println(obj);
17 obj = it.next();
18 System.out.println(obj);
19
20 System.out.println(it.hasNext());
21 obj = it.next();
22 System.out.println(obj);
23
24 System.out.println(it.hasNext());
25 */
26 while(it.hasNext()){
27 String str = (String)it.next();
28 System.out.println(str);
29 }
30
31 }
32 }
8.List接口存储字符串
Collection(接口)
|--List(接口)
|--ArrayList(类)：
|--Set(接口)
此例：左边使用List类型接收。但仍然使用Collection中的方法。效果跟之前是一样的。
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合对象
4 List list = new ArrayList();
5 //2.填充集合
6 list.add("张三");
7 list.add("李四");
8 list.add("王五");
9 list.add("周六");
10 //3.遍历集合
11 //方式一：toArray()
12 Object[] objArray = list.toArray();
13 for(int i = 0;i < objArray.length ; i++){
14 String str = (String)objArray[i];
15 System.out.println(str);
16 }
17 System.out.println("*************************");
18 //方式二：使用迭代器
19 Iterator it = list.iterator();
20 while(it.hasNext()){
21 String s = (String)it.next();
22 System.out.println(s);
23 }
24
25 }
26 }
9.List接口的特有方法
List接口中增加了一些特有功能，使其具有一些特性：
1.有序的(取出时的顺序跟存入时的顺序是一样的)；
2.可以存储重复的元素；
特有的成员方法：
void add(int index,E element)：在列表的指定位置插入指定元素（可选操作）。原index位置上的元素后移。
E remove(int index)：移除列表中指定位置的元素（可选操作）。
E get(int index):获取index位置上的元素；
E set(int index,E element)：将index位置上的元素替换为element。
ListIterator listIterator():特有的遍历迭代器
interface Collection{
boolean add(Object obj);
}
interface List extends Collection{
void add(int index,Object element);
}
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 List list = new ArrayList();
5 //2.填充集合:使用Collection --> add(Object obj):
6 list.add("刘德华");
7 list.add("张惠妹");
8 list.add("刘亦菲");
9 //使用List-->add(int index,Object obj)添加
10 list.add(1,"周星驰");
11
12 System.out.println("插入后：" + list);
13
14 //3.E remove(int index)
15 //移除周星驰
16 list.remove(1);
17 System.out.println("移除周星驰后：" + list);
18 //4.E get(int index)
19 //获取索引为1的
20 Object obj = list.get(1);
21 System.out.println("获取索引为1的：" + obj);
22
23 //5.E set(int index,E element)
24 //将索引为1的，替换为"周星驰"
25 list.set(1, "周星驰");
26 System.out.println("替换后：" + list);
27
28 }
29 }
10.List(接口)的特有迭代器：
ListIterator listIterator():一个可以向前遍历的迭代器；
注意：当使用此迭代器向前遍历时，一定要先向后遍历。
Iterator和ListIterator的区别：
1.Iterator是父接口：
Iterator是单向的，只能向下遍历；
2.ListIterator是Iterator的子接口；
ListIterator是双向的，可以向前遍历；
class ArrayList implements List{必须重写Collection接口的方法，必须重写List中的方法}
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 List list = new ArrayList();
5 //2.填充集合
6 list.add("张三");
7 list.add("李四");
8 list.add("王五");
9
10 //3.使用ListIterator迭代
11 ListIterator listIt = list.listIterator();
12 while(listIt.hasNext()){
13 String str = (String)listIt.next();
14 System.out.println(str);
15 }
16
17 System.out.println("*************向前遍历************");
18 //向前遍历
19 while(listIt.hasPrevious()){
20 String str = (String)listIt.previous();
21 System.out.println(str);
22 }
23 }
24 }
11.使用ListIterator时的并发修改异常
当我们通过"迭代器"遍历时，通过list的引用去修改集合内容时，会产生一个异常：ConcurrentModificationException。
所以：
当通过迭代器遍历时，如果想修改，就通过迭代器修改；
当使用list遍历时，如果想修改，可以通过list修改；
public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
List list = new ArrayList();
//2.填充集合
list.add("刘德华");
list.add("张学友");
list.add("郭富城");
//3.遍历集合
ListIterator listIt = list.listIterator();
while(listIt.hasNext()){
String str = (String)listIt.next();
System.out.println(str);
if(str.equals("张学友")){
//通过ListIterator向集合中添加一个元素
listIt.add("周星池");//OK的
// list.add("周星驰");//运行时异常：ConcurrentModificationException
}
}
}
}
12.List的三个子类的特点
1.ArrayList:数组实现；线程不安全的，效率高；
2.Vector:数组实现；线程安全的，效率低；
3.LinkedList:链表实现；线程不安全的，效率高
13.ArrayList存储字符串
Collection(接口)
|--List(接口)： 有序的；可以存储重复值；
|--ArrayList(类)：实现了所有List中的方法和Collection中的方法；
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 ArrayList list = new ArrayList();
5 //2.填充集合
6 list.add("aaa");//Collection中的方法
7 list.add(0, "bbb");//List中的方法；
8
9 //3.获取迭代器
10 Iterator it = list.iterator();//Collection中的方法
11 ListIterator listIt = list.listIterator();//List中的方法；
12
13 while(it.hasNext()){
14 System.out.println(it.next());
15 }
16 }
17 }
14.List特有的遍历方式
之前遍历集合的方式：
1.Collection --> toArray():
2.Collection --> iterator():
List接口，可以结合两个方法，进行遍历：
3.Collection --> size();
List --> get(int index):
使用for循环：
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 List list = new ArrayList();
5 //2.填充集合
6 list.add("藏獒");
7 list.add("金毛");
8 list.add("吉娃娃");
9 list.add("黑贝");
10 //3.遍历
11 for(int i = 0;i < list.size() ; i++){
12 System.out.println(list.get(i));
13 }
14 }
15 }
15.Vector特有功能
Collection(接口)
|--List(接口)：
|--ArrayList(类)：
|--Vector(类):
特有方法：
public void addElement(E obj)：添加一个元素；
public E elementAt(int index):返回指定索引处的引用；
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 Vector vec = new Vector();
5 //2.填充集合
6 vec.add("波斯猫");
7 vec.add("折耳猫");
8 vec.add("加菲猫");
9 vec.add("暹罗猫");
10
11 //3.遍历集合
12 for(int i = 0;i < vec.size() ; i++){
13 //使用List的get方法；
14 // String str = (String)vec.get(i);
15 //使用Vector特有的方法
16 String str = (String)vec.elementAt(i);
17 System.out.println(str);
18 }
19 }
20 }
16.LinkedList特有功能
Collection:
|--List:
|--ArrayList:
|--Vector:
|--LinkedList:
LinkedList类的特有功能：
public void addFirst(E e):将元素e添加到第一个位置上。原位置上的元素依次后移；可以模拟"栈"结构；
addLast(E e)：将元素e添加到末尾。
public E getFirst()及getLast()：获取第一个元素和最后一个元素；
public E removeFirst()及public E removeLast():删除第一个元素和最后一个元素；
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 LinkedList list = new LinkedList();
5 //2.填充元素：
6 list.addFirst("aaa");
7 list.addFirst("bbb");
8 list.addFirst("ccc");
9 //3.遍历元素：
10 for(int i = 0;i < list.size() ; i++){
11 System.out.println(list.get(i));
12 }
13 //4.获取第一个元素
14 System.out.println("第一个元素：" + list.getFirst());
15 System.out.println("最后一个元素：" + list.getLast());
16 //5.删除元素
17 System.out.println("删除第一个元素：" + list.removeFirst());
18 System.out.println("删除后的集合：" + list);
19 System.out.println("删除最后一个元素：" + list.removeLast());
20 System.out.println("删除后的集合：" + list);
21
22 }
23 }
17.去除ArrayList中重复字符串元素
1 public class Demo {
2 public static void main(String[] args) {
3 //1.实例化一个集合
4 ArrayList list = new ArrayList();
5 //2.填充集合
6 list.add("aaa");
7 list.add("bbb");
8 list.add("ccc");
9
10 list.add("aaa");
11 list.add("aaa");
12
13 //3.打印集合
14 System.out.println("list = " + list);
15
16 //*****去除集合中的重复元素******
17 //方式一：使用新集合
18 ArrayList list2 = new ArrayList();
19 //1.遍历原集合
20 for(int i = 0;i < list.size() ;i++){
21 String str = (String)list.get(i);
22 if(!list2.contains(str)){//如果在list2中不存在
23 list2.add(str);
24 }
25 }
26 //2.遍历新集合
27 System.out.println("新集合：" + list2);
28 //方式二：直接操作原集合
29 System.out.println("原集合：" + list);
30 //1.遍历原集合
31 for(int i = 0;i < list.size() ;i++){
32 String str = (String)list.get(i);
33 //将每个元素，与它后面的其它元素进行比较，如果有相同的。删除后面相同的元素
34 for(int j = i + 1 ; j < list.size() ; j++){
35 String str2 = (String)list.get(j);
36 if(str.equals(str2)){
37 //删除后面的元素
38 list.remove(j);
39 //删除元素后，集合的大小会发生变化。要保存j的一直性；
40 j--;
41 }
42 }
43 }
44 //2.打印集合
45 System.out.println("去重后，集合内容：" + list);
46
47 }
48 }