集合类
为什么出现集合类：
面向对象语言对事物的体现是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式
数组和集合类同是容器，区别：
数组虽然也可以存储对象，但长度是固定的：集合长度是可变的
数组中可以存储基本数据类型，集合只能存储对象
集合类的特点：
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
Collection接口:
Collection接口常见的的子接口有：List接口和Set接口
003390KRty6FyCV6YRU9e&690
因为数据的存储方式都有不同，所以出现了很多容器
Collection常见的方法：
l添加元素add()方法和addAll()：
Boolean add(Object obj);添加指定元素
1.add()方法的参数类型是Object ,以便于接收任意类型的对象
2.集合中存储的都是对象的引用（地址）
Boolean addAll(Collection c);将指定集合中的所有元素都添加到此集合
l获取个数：size()方法
Int size();获取此集合的元素个数
l删除元素：remove()方法和removeAll()、retainAll()、clean()方法
Boolean remove(Object obj);删除指定元素
Boolean removeAll(Collection c);删除指定集合中与此集合相同的所有元素，此调用返回true后，此集合中将不包含任何与指定集合相同的元素。注：此方法不是删除指定集合中的所有元素，而是删除交集的元素
Boolean retainAll(Collection c); 仅保留此集合中那些也包含在指定集合中的元素，取交集，当调用此方法返回为true时，此集合中只保留交集元素
Void Clean();删除此集合中的所有元素。
l判断：contains()方法、containsAll()、isEmpty()方法
Boolean contains(Object obj);判断指定元素是否存在
Boolean contansAll(Collection c);判断此集合中是否包含指定集合中的所有元素
Boolean isEmpty();判断此集合是否包含元素，是否为空集合
示例代码：
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
//创建集合容器，使用Collection接口的子类ArrayList
ArrayList al=new ArrayList();
//1.添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//打印集合
sop("源集合"+al);
//3.删除元素
al.remove("java02");
//al.clean();//清空结合
//4.判断元素
sop("java03是否存在："+al.contains("java03"));
sop("集合是否为空"+al.isEmpty());
//2.获取个数，集合长度
sop("删除后size:"+al.size());
//打印改变后的集合
sop(al);
}
//打印方法
public static void sop(Object obj){
System.out.println(obj);
}
}
结果：
003390KRty6FyCYiZEp2d&690
方法retainAll()演示代码
/*
演示retainAll()方法，取两个集合的交集
*/
import java.util.*;
class Collection_retainAllDemo
{
public static void main(String[] args)
{
/*
分别创建两个集合容器，并分别向各个容器中添加元素
*/
ArrayList al1=new ArrayList();
ArrayList al2=new ArrayList();
//向al1中添加元素
al1.add("java01");
al1.add("java02");
al1.add("java03");
//向al2中添加元素
al2.add("java01");
al2.add("java02");
al2.add("java04");
al2.add("java05");
al1.retainAll(al2);
System.out.println("al1与al2的交集："+al1);
}
}
结果：
003390KRty6FyD1lWd79d&690
l获取元素iterator()方法
Itrerator iterator();返回在此 collection 的元素上进行迭代的迭代器,就是获取迭代器，用于取出集合中的元素
Itrerator 的原理：
Itrerator(迭代器)其实就是集合的取出元素方法，它是把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素，那么取出方式就是被定义成了内部类，而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容，判断和取出，那么可以将其共性取出，那么这些内部类都符合一个规则，该规则是Iterator接口。
使用迭代获取集合中的对象：方法：
使用它对外提供的两个方法
Boolean hasNext();如果仍有元素可以迭代，则返回true。
next();返回迭代的下一个元素;
使用Iterator获取集合中的元素，示例代码：
/*
演示取出集合元素iterator()方法
*/
import java.util.*;
class Collection_iteratorDemo
{
public static void main(String[] args)
{
//创建集合容器
ArrayList al=new ArrayList();
//向集合中添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
/*获取集合中的元素,使用的Iterator
boolean hasNext();是否还有元素可以迭代，如有返回true
next();返回迭代的下一个元素
*/
Iterator it=al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
结果：
003390KRty6FyD3SmlO40&690
Collection常见子接口(List和Set)特点：（每个容器对数据的存储方式都不同,就是数据结构不一样）
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢（线程不同步）
|--LinkedList:底层使用的是链表数据结构：特点：增删的速度很快，查询稍慢
|--Vector:底层是数组数据结构，与ArrayList功能相同（线程同步，被ArrayList替代了）
|--Set:元素是无序的，元素不可以重复
List接口:
特有方法,凡是可以操作角标的方法都是该体系特有的方法
增：
add(index,element); 在列表的指定位置插入指定元素，将当前处位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）
boolean addAll(Collection c);
删:remove( index)；删除指定角标位置的元素
改: set(index,element);修改指定角标的元素
查:Object get(index);获取指定角标的元素
subList(fromIndex,toIndex);返回列表中指定的fromIndex（包括）和toIndex（不包括）之间的部分
ListIterator listIterator();返回此列表元素的列表迭代器（按适当顺序）。
int indexOf();返回此列表中第一次出现的指定元素的索引, 如果此列表不包含该元素，则返回-1
int lastIndexOf(Object o): 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1
ListIterater(列表迭代器：)
List集合特有的迭代器，ListInterator是Iterator的子接口
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为发
生ConcurrentModifiception异常，所以在迭代时，只能用迭代器
的方法操作元素，可是Iterator方法是有限的，只能对元素进行
判断，取出，删除的操作,如果想要其他的操作如添加，修改等，
就需要使用其子接口ListIterator,
该接口只能通过List集合的listIterator方法获取
listIterator常见方法：
void add(E e)；将指定元素添加到集合
boolean hasNext()；以正向遍历列表时，是否还有元素可以迭代，则返true
boolean hasPrevious()；如果以逆向遍历列表，是否还有元素可以迭代，则返回 true。
Enext()；返回列表中的下一个元素
Eprevious()；返回列表中的前一个元素
void set(E e)；修改返回的元素
void remove()；从列表中删除返回的元素。对于每个 next或 previous调用，只能执行一次此调用。只有在最后一次调用 next或 previous之后，尚未调用 ListIterator.add时才可以执行该调用。
示例代码：
import java.util.*;
class ListIteratorDemo
{
public static void main(String[] args)
{
//创建集合容器
ArrayList al=new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//在迭代器过程中，进行操作
ListIterator li=al.listIterator();
while(li.hasNext()){
Object obj=li.next();
if(obj.equals("java02")){
//li.add("java009");//在java02后面添加java09
li.set("java007");//将java02修改成007；
}
}
//将集合中的元素反向获取
while(li.hasPrevious()){
System.out.println(li.previous());
}
System.out.println(al);
}
}
结果：
003390KRty6FyD7hV582a&690
Vector类:
底层是数组数据结构，与ArrayList功能相同，不同处Vector是线程同步，
被ArrayList替代，但是有一个方法：Enumeration elements()返回的是此向量的枚举
接口 Enumeration
枚举就是Vecto特有的取出方式，此接口的功能与Iterator接口的功能是重复的，并且Iterator接口添加了一个可选移除操作，而且使用较短的方法名，所以被迭代器所取代了，但是在IO中有个对对象会使用到它，那个对象是1.0出现的，那是没有迭代器
Enumeration接口中的方法：
它只有两个方法：
boolean hasMoreElements()；判断此枚举是否包含更多的元素。返回true
EnextElement()；返回此枚举的下一个元素
示例代码：
import java.util.*;
class VectorDemo
{
public static void main(String[] args)
{
//创建集合容器
Vector v=new Vector();
v.add("java01");
v.add("java04");
v.add("java03");
v.add("java02");
//获取枚举
Enumeration en=v.elements();
//使用枚举方式显示集合中的元素
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
}
}
结果：
003390KRty6FyDa0pbW08&690
LinkedList类：
特有方法：
AddFirst(Object obj);将指定元素插入此列表的开头
addLast(Object obj));将指定元素添加到此列表的结尾。
Get方法是获取元素不删除
getFirst();返回此列表的第一个元素。
getLast();返回此列表的最后一个元素。
Remove方法：获取元素并删除
removeFirst();移除并返回此列表的第一个元素
removeLast();移除并返回此列表的最后一个元素。
当集合中为空时获取与删除方法会抛出NoSuchElementException（没有这个元素异常）异常，后来LinkList升级了，在JDK1.6出现了替代方法
boolean offerFirst(E e)；在此列表的开头插入指定的元素。
boolean offerLast(E e)；在此列表末尾插入指定的元素。
peekFirst()；获取但不移除此列表的第一个元素；如果此列表为空，则返回null。
peekLast()；获取但不移除此列表的最后一个元素；如果此列表为空，则返回null。
pollFirst()；获取并移除此列表的第一个元素；如果此列表为空，则返回null。不再抛出异常
pollLast()；获取并移除此列表的最后一个元素；如果此列表为空，则返回null。不再抛出异常
示例代码：
import java.util.*;
class LinkedListDemo
{
public static void main(String[] args)
{
//创建集合容器
LinkedList link=new LinkedList();
//使用addFirst()方法，将指定元素添加到列表开头
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
System.out.println(link);
//获取列表的第一个和最后一个元素
System.out.println("第一个元素是："+link.getFirst());
System.out.println("最后一个元素是："+link.getLast());
//删除并获取元素
System.out.println("删除最后一个元素是："+link.removeLast());
//获取元素，不用迭代器
while(!(link.isEmpty())){
System.out.println(link.removeFirst());
}
}
}
结果：
003390KRty6FyDdZ0Nu04&690
练习1：使用LinkedList模拟一个堆栈或者队列数据结构
堆栈：先进后出，如同一个杯子
队列：先进先出，如同一个水管
示例代码：
import java.util.*;
class DuiLie
{
private LinkedList link;
//构造方法,一初始化就有link
DuiLie(){
link=new LinkedList();
}
//添加元素，在列表首位添加
public void myAdd(Object obj){
link.addFirst(obj);
}
//获取第一个元素方法
public Object myGet(){
return link.getLast();
}
//判断集合是否空方法
public boolean isNull(){
return link.isEmpty();
}
}
class TestDuiLie
{
public static void main(String[] args)
{
DuiLie d=new DuiLie();
d.myAdd("java01");
d.myAdd("java02");
d.myAdd("java03");
d.myAdd("java04");
while(d.isNull()){
System.out.println(d.myGet());
}
}
}
结果：
003390KRty6FyDgIjhb35&690
练习2：去除ArrayList集合中的重复元素
示例代码：
import java.util.*;
class ArrayList_removeAll
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
al.add("java01");
al.add("java02");
System.out.println(singleDlement(al));
}
//去除相同元素方法
public static ArrayList singleDlement(ArrayList al){
//定义一个临时容器
ArrayList newAl=new ArrayList();
//遍历集合
Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!(newAl.contains(obj))){
newAl.add(obj);
}
}
return newAl;
}
}
结果：
003390KRty6FyDiIul573&690
练习3：将自定义对象作为元素存到ArrayList集合中，并去除重复元素，比如：存人对象，同姓名同年龄，视为同一个人，为重复元素
思路：
1.对人描述，将数据封装进人对象
2.定义容器，将人存入
3.取出
List集合判断元素是否相同，依据的是元素的equals方法
Equals与compareTo
Equals返回的是boolean类型
CompareTo返回的是int类型
示例代码：
import java.util.*;
class Person
{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
//覆盖equals方法
public boolean equals(Object obj){
if(!(obj instanceof Person))
return false;
Person p=(Person)obj;
return this.name.equals(p.name)&&(this.age==p.age);
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
class ArrayListTest
{
public static void main(String[] args)
{
//创建集合容器
ArrayList al=new ArrayList();
//存入对象
al.add(new Person("lisi01",30));
al.add(new Person("lisi02",32));
al.add(new Person("lisi01",30));
al.add(new Person("lisi04",35));
al=singleDlement(al);
//获取
Iterator it=al.iterator();
while(it.hasNext()){
Person p=(Person)it.next();
System.out.println(p.getName()+"::"+p.getAge());
}
}
//去除相同元素方法
public static ArrayList singleDlement(ArrayList al){
//定义一个临时容器
ArrayList newAl=new ArrayList();
//遍历集合
Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!(newAl.contains(obj))){
newAl.add(obj);
}
}
return newAl;
}
}
结果：
阅读(1313) | 评论(0) | 转发(0) |
