java--集合（1）--黑马程序员

------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

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
Collection list = new ArrayList();
//2.boolean add(Object e)：填充集合
System.out.println(list.add("刘德华"));
System.out.println(list.add("刘德华"));
System.out.println(list.add("张学友"));
System.out.println(list.add("刘亦菲"));
System.out.println("打印集合："  + list);

//3.boolean remove(Object o):将元素o从集合中删除
//从集合中移除"张学友"
/*
list.remove("张学友");//内部使用：equals()方法进行逐个判断。如果为true，则认为是相同元素，就执行删除
System.out.println("移除张学友后，打印集合："  + list);
*/
/*
list.remove("刘德华");
System.out.println("移除1刘德华后，打印集合："  + list);
list.remove("刘德华");
System.out.println("移除2刘德华后，打印集合："  + list);
*/
//4.void clear()
/*
list.clear();
System.out.println("清空集合后，打印集合：" + list);
*/
//5.boolean contains(Object o)：查找集合中的元素o，如果有：返回true，否则返回false;
//在集合中查找"刘德华"
System.out.println("集合中是否存在刘德华:" + list.contains("刘德华"));//true
System.out.println("集合中是否存在范冰冰:" + list.contains("范冰冰"));//false
//6.boolean isEmpty():判断集合是否为空:
System.out.println("集合是否为空：" + list.isEmpty());
System.out.println("集合大小：" + list.size());
list.clear();
System.out.println("清空集合后，集合是否为空：" + list.isEmpty());
System.out.println("清空集合后，集合大小：" + list.size());
}
}

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 中的所有元素。

public class Demo {
public static void main(String[] args) {
//定义两个集合
Collection list1 = new ArrayList();
list1.add("刘德华");
list1.add("张学友");
list1.add("刘亦菲");

Collection list2 = new ArrayList();
list2.add("马云");
list2.add("柳传志");
list2.add("马化腾");

//1.boolean addAll(Collection c)
/*
list1.addAll(list2);
System.out.println(list1);
System.out.println(list2);
*/
//2.boolean removeAll(Collection c)
/*
list1.removeAll(list2);
System.out.println("list1 = " + list1);
System.out.println("list2 = " + list2);
*/
//3.boolean containsAll(Collection c)
/*
System.out.println(list1.containsAll(list2));
*/
//4.boolean retainAll(Collection c)
list1.retainAll(list2);
System.out.println("list1 = " + list1);
System.out.println("list2 = " + list2.toString());
}
}

5.collection的遍历

public class Demo {
public static void main(String[] args) {
//1.定义集合
Collection list = new ArrayList();
//2.填充集合
list.add("刘德华");
list.add("张学友");
list.add("郭富城");
list.add("黎明");

//3.遍历集合
//    System.out.println(list);//这不是遍历，是获取一个String
Object[] objArray = list.toArray();
for(int i = 0 ;i < objArray.length ; i++){
String s = (String)objArray[i];
System.out.println(s);
//    System.out.println(objArray[i]);//调用Object-->toString()
}
}
}

6.Collection存储自定义对象

import java.util.ArrayList;
import java.util.Collection;

public class Demo {
public static void main(String[] args) {
//1.定义集合
Collection list = new ArrayList();
//2.填充集合
/*
Cat c1 = new Cat("波斯猫",2,'雌');
list.add(c1);
*/
list.add(new Cat("波斯猫",2,'雌'));
list.add(new Cat("折耳猫",3,'雄'));
list.add(new Cat("熊猫",4,'雌'));
list.add(new Cat("大脸猫",2,'雄'));

//3.遍历集合
Object[] objArray = list.toArray();
for(int i = 0 ;i < objArray.length ; i++){
Cat c = (Cat)objArray[i];
System.out.println(c.getName() + "," + c.getAge() + "," + c.getSex());
}

}

7.Collection遍历集合_迭代器

Collection集合的遍历方式二：

迭代器：

Iterator iterator():

java.util.Iterator(接口):
成员方法：
boolean hasNext() 如果仍有元素可以迭代，则返回 true。

Object next() 返回迭代的下一个元素。

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合类；
Collection list = new ArrayList();
//2.填充集合
list.add("张三");
list.add("李四");
list.add("王五");
list.add("周六");
//3.使用迭代器遍历
Iterator it = list.iterator();
/*
Object obj = it.next();
System.out.println(obj);
obj = it.next();
System.out.println(obj);
obj = it.next();
System.out.println(obj);

System.out.println(it.hasNext());
obj = it.next();
System.out.println(obj);

System.out.println(it.hasNext());
*/
while(it.hasNext()){
String str  = (String)it.next();
System.out.println(str);
}

}
}

8.List接口存储字符串

Collection(接口)
|--List(接口)
|--ArrayList(类)：
|--Set(接口)

此例：左边使用List类型接收。但仍然使用Collection中的方法。效果跟之前是一样的。

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合对象
List list = new ArrayList();
//2.填充集合
list.add("张三");
list.add("李四");
list.add("王五");
list.add("周六");
//3.遍历集合
//方式一：toArray()
Object[] objArray = list.toArray();
for(int i = 0;i < objArray.length ; i++){
String str = (String)objArray[i];
System.out.println(str);
}
System.out.println("*************************");
//方式二：使用迭代器
Iterator it = list.iterator();
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s);
}

}
}

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);
　　 }
　　

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
List list = new ArrayList();
//2.填充集合:使用Collection --> add(Object obj):
list.add("刘德华");
list.add("张惠妹");
list.add("刘亦菲");
//使用List-->add(int index,Object obj)添加
list.add(1,"周星驰");

System.out.println("插入后：" + list);

//3.E remove(int index)
//移除周星驰
list.remove(1);
System.out.println("移除周星驰后：" + list);
//4.E get(int index)
//获取索引为1的
Object obj = list.get(1);
System.out.println("获取索引为1的：" + obj);

//5.E set(int index,E element)
//将索引为1的，替换为"周星驰"
list.set(1, "周星驰");
System.out.println("替换后：" + list);

}
}

10.List(接口)的特有迭代器：

ListIterator listIterator():一个可以向前遍历的迭代器；
注意：当使用此迭代器向前遍历时，一定要先向后遍历。

Iterator和ListIterator的区别：
　　1.Iterator是父接口：
　　　　 Iterator是单向的，只能向下遍历；

　　2.ListIterator是Iterator的子接口；
　　　　ListIterator是双向的，可以向前遍历；

class ArrayList implements List{必须重写Collection接口的方法，必须重写List中的方法}

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
List list = new ArrayList();
//2.填充集合
list.add("张三");
list.add("李四");
list.add("王五");

//3.使用ListIterator迭代
ListIterator listIt = list.listIterator();
while(listIt.hasNext()){
String str = (String)listIt.next();
System.out.println(str);
}

System.out.println("*************向前遍历************");
//向前遍历
while(listIt.hasPrevious()){
String str = (String)listIt.previous();
System.out.println(str);
}
}
}

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中的方法；

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
ArrayList list = new ArrayList();
//2.填充集合
list.add("aaa");//Collection中的方法
list.add(0, "bbb");//List中的方法；

//3.获取迭代器
Iterator it = list.iterator();//Collection中的方法
ListIterator listIt = list.listIterator();//List中的方法；

while(it.hasNext()){
System.out.println(it.next());
}
}
}

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));
}

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
List list = new ArrayList();
//2.填充集合
list.add("藏獒");
list.add("金毛");
list.add("吉娃娃");
list.add("黑贝");
//3.遍历
for(int i = 0;i < list.size() ; i++){
System.out.println(list.get(i));
}
}
}

15.Vector特有功能

Collection(接口)
|--List(接口)：
|--ArrayList(类)：
|--Vector(类):
特有方法：
　　public void addElement(E obj)：添加一个元素；
　　 public E elementAt(int index):返回指定索引处的引用；
　　
　　

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
Vector vec = new Vector();
//2.填充集合
vec.add("波斯猫");
vec.add("折耳猫");
vec.add("加菲猫");
vec.add("暹罗猫");

//3.遍历集合
for(int i = 0;i < vec.size() ; i++){
//使用List的get方法；
//    String str = (String)vec.get(i);
//使用Vector特有的方法
String str = (String)vec.elementAt(i);
System.out.println(str);
}
}
}

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():删除第一个元素和最后一个元素；

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
LinkedList list = new LinkedList();
//2.填充元素：
list.addFirst("aaa");
list.addFirst("bbb");
list.addFirst("ccc");
//3.遍历元素：
for(int i = 0;i < list.size() ; i++){
System.out.println(list.get(i));
}
//4.获取第一个元素
System.out.println("第一个元素：" + list.getFirst());
System.out.println("最后一个元素：" + list.getLast());
//5.删除元素
System.out.println("删除第一个元素："  + list.removeFirst());
System.out.println("删除后的集合：" + list);
System.out.println("删除最后一个元素：" + list.removeLast());
System.out.println("删除后的集合：" + list);

}
}

17.去除ArrayList中重复字符串元素

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
ArrayList list = new ArrayList();
//2.填充集合
list.add("aaa");
list.add("bbb");
list.add("ccc");

list.add("aaa");
list.add("aaa");

//3.打印集合
System.out.println("list = " + list);

//*****去除集合中的重复元素******
//方式一：使用新集合
ArrayList list2 = new ArrayList();
//1.遍历原集合
for(int i = 0;i < list.size() ;i++){
String str = (String)list.get(i);
if(!list2.contains(str)){//如果在list2中不存在
list2.add(str);
}
}
//2.遍历新集合
System.out.println("新集合：" + list2);
//方式二：直接操作原集合
System.out.println("原集合：" + list);
//1.遍历原集合
for(int i = 0;i < list.size() ;i++){
String str = (String)list.get(i);
//将每个元素，与它后面的其它元素进行比较，如果有相同的。删除后面相同的元素
for(int j = i + 1 ; j < list.size() ; j++){
String str2 = (String)list.get(j);
if(str.equals(str2)){
//删除后面的元素
list.remove(j);
//删除元素后，集合的大小会发生变化。要保存j的一直性；
j--;
}
}
}
//2.打印集合
System.out.println("去重后，集合内容："  + list);

}
}