标签：
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
主要内容：《 数组的局限性、Collection接口的结构和基本方法、批量操作、遍历、迭代器、list接口、list接口方法、ArrayList、Vector 》
当我们面向对象编程时，总要处理大量的对象；
1.处理大量对象，可以使用"数组"存储；
2.但数组有很多的局限性：
1).数组的长度一旦确定，后期不能更改；我们程序员可以定义新的数组，但是每次做这样的操作都很费事；
2).数组在定义时，指定了"数据类型"，那么这个数组就只能装这个数据类型的，不能装其它类型的。
3.以上的两个局限性，对于我们程序员来说，在操作大量对象时，就非常的不方便。 所以这时，Java为我们提供了一种"工具"。它类似于"仓库"，可以用来存 储大量的"引用"。
这种"仓库"就是："集合类"；
特点：
1).对于我们程序员来说，就像一个"无底洞"，可以装无数的"引用"；我们不用关心"长度"信息；
2).这些"集合类"可以装任何"引用数据"类型的数据；
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
当我们通过"迭代器"遍历时，通过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 } } } }
1.ArrayList:数组实现；线程不安全的，效率高；
2.Vector:数组实现；线程安全的，效率低；
3.LinkedList:链表实现；线程不安全的，效率高
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 }
之前遍历集合的方式：
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 }
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 }
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 }
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 }
标签：
原文地址：http://www.cnblogs.com/linmusen/p/4709257.html
