集合
一.体系概述
集合类：
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点：
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
插入图片：集合框架的构成及分类.jpg
插入图片：集合框架的体系结构.jpg
二.共性方法
1.add方法的参数类型是Object，以便于接受任意类型对象。
2.集合中存储的都是对象的引用（地址）。
创建一个集合容器，使用collection接口的子类。ArrayList
例：ArrayListal=new ArrayList();
打印集合
打印集合对象al，就直接打印出集合中所有的元素,用中括号括起来。（例：[......]）
a.添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
b.获取个数。集合长度。
al.size(); //返回当前集合中元素的数量
c.删除元素
al.remove("java02");
al.clear(); //清空集合
d.判断元素
al.contains("java03"); //判断java03是否存在
al.isEmpty(); //判断集合是否为空？
例：
public static void method_2()
{
ArrayListal1=new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayListal1=new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
al1.retainAll(al2); //去交集，all中只会保留和al2中相同的元素。（al1的结果是：java01，java02；如何没有公共元素的话，al1的值就是空）
al1.removeAll(al2); //移除与al2中相同的元素（al1结果就是：java03，java04）
}三.迭代器
什么是迭代器？
其实就是集合的取出元素的方式。
插入图片：迭代器的特点.jpg
取出集合中的元素
Iteratorit=al.iterator(); //迭代器接口，返回Iterator接口的子类对象。获取迭代器，用于取出集合中的元素。
it.next(); //返回迭代的下一个元素，从第一个元素开始，取出一个元素，一次只能取一个元素
it.hasNext(); //如何任有元素迭代，返回true
while（it.hasNext()）
{
sop(it.next());
}
for(Iteratorit=al.iterator();it.hasNext();)
{
sop(it.next());
}四.List集合共性方法
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程不同步。
|--LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
|--Set:元素是无序，元素不可以重复。
List:
特有方法，凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();
intindexOf(obj):获取指定元素的位置。
ListIteratorlistIterator();
例：
publicstatic void main(String[] args)
{
ArrayListal=new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
//在指定位置添加元素。
al.add(1,"java09"); //在下标为1的地方添加"java09"
//删除指定位置的元素。
al.remove(2); //删除下标为2的元素
//修改元素
al.set(2,"java007"); //将下标为2的元素的值修改为“java007”
//通过角标获取元素。
al.get(1); //获取角标为1的元素的值
//获取所有元素。
for(intx=0;x<al.size();x++)
{
System.out.println("al("+x+")="+al.get(x));
}
//迭代器的获取所有元素
Iteratorit=al.iterator();
while(it.hasNext())
{
sop("next:"+it.next());
}
}五.ListIterator
//通过indexof获取对象的位置。
sop("index="+al.indexof("java02")); //获取"java02"元素的下标
Listsub=al.subList(1,3); //返回子列表中指定范围的值。获取元素包含头不包含尾（获取角标为1和2的元素）
列表迭代器
//在迭代过程中，准备添加或者删除元素。
Iterator it=al.iterator();
while(it.hasNext())
{
Objectobj=it.next();
if(obj.equals("java02"))
//al.add("java08"); //不能进行添加
it.remove(); //将java02的引用从集合中删除了。
}List集合特有的迭代器，ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException（并发修改异常）异常，所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。
如果想要其他的操作如添加，修改等，就需要使用其
子接口，ListIterator。该接口只能通过List集合ListIterator方法获取。
例：
ListIterator元素中都带角标所以具有增删改查的功能。
ListIterator li=al.listIterator();
while(li.hasNext())
{
Objectobj=li.next();
if(obj.equals("java02"))
li.add("java09"); //在指定的元素后面添加相应的值（在java02后面添加java09）
li.set("java006"); //修改指定的元素（将java02修改为java006）
}
//hasPrevious（） 如果以逆向编译列表，列表迭代器有多个元素，则返回true。（hasPrevious是看前面有没有元素，hasNext是看后面有没有元素）
li.hasPrevious(); //看前面是否有元素
while(li.hasPrevious())
{
sop("pre::"+li.previous()); //从后向前依次取出元素
}六.List集合具体对象的特点
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程不同步。
|--LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
|--Set:元素是无序，元素不可以重复。
List:
特有方法，凡是可以操作角标的方法都是该体系特有的方法。
七.Vector中的枚举
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。枚举郁郁而终了。
例：
import java.util.*;
class VectorDemo
{
publicstatic void main(String[] args)
{
Vectorv=new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumerationen=v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement);
}
}
}八.集合框架(LinkedList)
LinkedList:特有方法。
addFirst();
addLast();
getFirst();
getLast();
获取元素，但是不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但是不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
九.集合框架（HashSet）
Set：元素是是顺序不一定一致），元素不可以重复。
HashSet：底层数据结构是哈希表。
HashSet是如何保证元素唯一性的？
是通过元素的两个方法，hashCode和equals是否为true。
如果元素的hashCode值不同，不会调用equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
TreeSet：
Set集合的功能和Collection的功能是一致的。
例：
class HashSetDemo
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
｝
publicstatic void main(String[] args)
{
HashSeths=new HashSet();
sop(hs.add("java01")); //输出ture
sop(hs.add("java01")); //输出false，因为数据已经存在所以不能重复。
hs.add("java02");
hs.add("java03");
hs.add("java03"); //重复数据只打印一次
hs.add("java04");
Iteratorit=hs.iterator();
while(it.hasNext())
{
sop(it.next); //打印时是无序的，不是按照存入的顺序打印的。
}
}
}例：HashSet的存储、判断和删除
import java.util.*;
class HashSetTest
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
publicstatic void main(String[] args)
{
HashSeths=new HashSet();
hs.add(newPerson("a1",11));
hs.add(newPerson("a2",12));
hs.add(newPerson("a3",13));
//hs.add(newPerson("a2",12));
hs.add(newPerson("a4",14));
//sop("a1:"+hs.contains(newPerson("a2",12))); //判断元素是否存在，先判断hashCode，再判断equals。
hs.remove(newPerson("a4",14));
Iteratorit=hs.iterator();
while(it.hasNext())
{
Personp=(Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
privateString name;
privateint age;
Person(Stringname,int age)
{
this.name=name;
this.age=age;
}
publicint hashCode()
{
System.out.println(this.name+"...hashCode");
returnname.hashCode()+age*37; //乘以37的让哈希值定量不相同
}
publicboolean equals(Object obj)
{
if(!(objinstanceof Person))
returnfalse;
Personp=(Person)obj;
System.out.println(this.name+"...equals..."+p.name);
returnthis.name.equals(p.name)&&this.age==p.age;
}
publicString getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
}十.集合框架（TreeSet）
TreeSet:可以对Set集合中的元素进行排序。 （按照Ascll码值进行排序）
记住：排序时，当主要条件相同时，一定要判断一下次要条件。
例：
/*
需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。
*/
import java.util.*;
class TreeSetDemo
{
publicstatic void main(String[] args)
{
TreeSetts=new TreeSet();
ts.add(newStudent("lisi02",22));
ts.add(newStudent("lisi007",20));
ts.add(newStudent("lisi09",19));
ts.add(newStudent("lisi08",19));
ts.add(newStudent("lisi007",20));
//ts.add(newStudent("lisi01",40));
Iteratorit=ts.iterator();
while(it.hasNext())
{
Studentstu=(Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable //该接口强制让学生具备比较性。
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name=name;
this.age=age;
}
publicint compareTo(Object obj)
{
if(!(objinstanceof Student))
thrownew RuntimeException("不是学生对象");
Students=(Student)obj;
System.out.println(this.name+"...compareto..."+s.name);
if(this.age>s.age)
return1;
if(this.age==s.age)
{
returnthis.name.compareTo(s.name);
}
return-1;
}
publicString getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
}List接口对Collection进行了简单的扩充，它的具体实现类常用的有ArrayList和LinkedList。
你可以将任何东西放到一个 List容器中，并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快，而 LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。前面说的Iterator只能对容器进行向前遍历，而ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。
(1) 面向位置的操作包括插入某个元素或Collection 的功能，还包括获取、除去或更改元素的功能。在 List 中搜索元素可以从列表的头部或尾部开始，如果找到元素，还将报告元素所在的位置 :
voidadd(int index, Object element): 在指定位置index上添加元素element
boolean addAll(int index, Collection c): 将集合c的所有元素添加到指定位置index
Object get(int index): 返回List中指定位置的元素
intindexOf(Object o): 返回第一个出现元素o的位置，否则返回-1
intlastIndexOf(Object o) ：返回最后一个出现元素o的位置，否则返回-1
Object remove(int index) ：删除指定位置上的元素
Object set(int index, Object element) ：用元素element取代位置index上的元素，并且返回旧的元素
(2) List 接口不但以位置序列迭代的遍历整个列表，还能处理集合的子集：
ListIterator listIterator() : 返回一个列表迭代器，用来访问列表中的元素ListIterator listIterator(int index) : 返回一个列表迭代器，用来从指定位置index开始访问列表中的元素List subList(int fromIndex, int toIndex) ：返回从指定位置fromIndex（包含）到toIndex（不包含）范围中各个元素的列表视图“对子列表的更改（如 add()、remove() 和 set() 调用）对底层 List 也有影响。”“ArrayList 和 LinkedList 都实现 Cloneable 接口，都提供了两个构造函数，一个无参的，一个接受另一个Collection”。
LinkedList类
LinkedList类添加了一些处理列表两端元素的方法。
(1) void addFirst(Object o): 将对象o添加到列表的开头
void addLast(Object o)：将对象o添加到列表的结尾
(2) Object getFirst(): 返回列表开头的元素
Object getLast(): 返回列表结尾的元素
(3) Object removeFirst(): 删除并且返回列表开头的元素
Object removeLast():删除并且返回列表结尾的元素
(4) LinkedList(): 构建一个空的链接列表
LinkedList(Collection c): 构建一个链接列表，并且添加集合c的所有元素
“使用这些新方法，您就可以轻松的把 LinkedList 当作一个堆栈、队列或其它面向端点的数据结构。”
ArrayList类
ArrayList类封装了一个动态再分配的Object[]数组。每个ArrayList对象有一个capacity。这个capacity表示存储列表中元素的数组的容量。当元素添加到ArrayList时，它的capacity在常量时间内自动增加。
在向一个ArrayList对象添加大量元素的程序中，可使用ensureCapacity方法增加capacity。这可以减少增加重分配的数量。
(1)void ensureCapacity(int minCapacity): 将ArrayList对象容量增加minCapacity
(2)void trimToSize(): 整理ArrayList对象容量为列表当前大小。程序可使用这个操作减少ArrayList对象存储空间。
2万+
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
