三、Set

王朝学院·作者佚名 2016-08-27

宽屏版字体: 小 | 中 | 大 | 超大

一、集合的出现

1.1、集合简述

面向对象语言对事物的体现都是以对象形式，为了方便对多个对象的操作，就对象对象进行存储，集合就是存仪储对象最常用的一种试

1.2、数组和集合都是容器

数组也存对象，存储同一种类型，但数组是固定长度的，集合长度是可变。

数组中可以存储基本数据类型，集合只能存储对象

1.3、集合特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

1.4、结构

二、集合共性方法

2.1、Collection接口顶级

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如Set和List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

2.2、共性方法

方法摘要boolean

add(E e)

确保此 collection 包含指定的元素（可选操作）。

boolean

addAll(Collection<? extends E> c)

将指定

collection 中的所有元素都添加到此 collection 中（可选操作）。

void

clear()

移除此 collection 中的所有元素（可选操作）。

boolean

contains(Object o)

如果此 collection 包含指定的元素，则返回true。

boolean

containsAll(Collection<?> c)

如果此 collection 包含指定 collection 中的所有元素，则返回true。

boolean

equals(Object o)

比较此 collection 与指定对象是否相等。

int

hashCode()

返回此 collection 的哈希码值。

boolean

isEmpty()

如果此 collection 不包含元素，则返回true。

Iterator<E>

iterator()

返回在此 collection 的元素上进行迭代的迭代器。

boolean

remove(Object o)

从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

boolean

removeAll(Collection<?> c)

移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean

retainAll(Collection<?> c)

仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

int

size()

返回此 collection 中的元素数。

Object[]

toArray()

返回包含此 collection 中所有元素的数组。

<T>

T[]

toArray(T[] a)

返回包含此 collection

中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

2.3、ArrayList示例

importjava.util.*;classCollectionDemo {publicstaticvoidmain(String[] args) {//声明2个集合容器，并添加元素List<String> ar1 =newArrayList<String>();

ar1.add("a");

ar1.add("b");

ar1.add("c");

ar1.add("d");

ar1.add("e");//遍历sop("ar1遍历:");

getIterator(ar1);

List<String> ar2 =newArrayList<String>();

ar2.add("a");

ar2.add("b");

ar2.add("f");

ar2.add("q");

ar2.add("w");//增强for循环遍历sop("ar2遍历:");

getFor(ar2);//求集合的长度sop("ar1的长度:" +ar1.size());

sop("ar2的长度:" +ar2.size());//比较判断sop("ar1中有字符a吗 : " + ar1.contains("a"));//整个集合比较sop("ar1中有字符ar2吗 : " +ar1.containsAll(ar2));//求交集ar1.retainAll(ar2);

sop("求交集");

getFor(ar1);//addALLar1.addAll(ar2);//增强for循环遍历sop("添加ar2后的ar1:");

getFor(ar1);//删除ar1.remove("c");

sop("ar1删除指定c后");

getFor(ar1);

sop("ar1删除指定集合");

ar1.removeAll(ar2);

getFor(ar1);

sop("ar1是空吗？" +ar1.isEmpty());//清空ar1.clear();

sop(ar1.size());

}//iterator遍历集合publicstaticvoidgetIterator(List<String>list) {

Iterator<String> iterator =list.iterator();while(iterator.hasNext()) {

String str=iterator.next();

sop(str);

}

}//forEach遍历publicstaticvoidgetFor(List<String>list) {for(String str : list) {

sop(str);

}

}//打印publicstaticvoidsop(Object obj) {

System.out.PRintln(obj);

}

结果：

ar1遍历:

ar2遍历:

ar1的长度:5ar2的长度:5ar1中有字符a吗 :truear1中有字符ar2吗 :false求交集

添加ar2后的ar1:

ar1删除指定c后

ar1删除指定集合

ar1是空吗？true0

2.4、Iterator

方法摘要boolean

hasNext()

如果仍有元素可以迭代，则返回true。

next()

返回迭代的下一个元素。

void

remove()

从迭代器指向的 collection

中移除迭代器返回的最后一个元素（可选操作）。

2.5、ArrayList

importjava.util.ArrayList;importjava.util.Iterator;importjava.util.List;/*** List:元素是有序的，元素可以重复，该集合体系有索引

* Set:元素是无序，元素不可以重复

* List:

* 特有方法：可以操作索引的方法都是特有

* add(index ,element)

* addAll(index,Collection);

* remove (index)

* set(index,element)

* get(index);

* subList(from,to)

* listIterator()

**/publicclassListDemo {publicstaticvoidmain(String[] args) {//add();//remove();//set();//getIndex();indexSub();

}//indexOf和subListpublicstaticvoidindexSub(){

List<String> list=newArrayList<String>();//添加元素list.add("java01");

list.add("java02");

list.add("java03");

list.add("java04");

list.set(2,"hello");

sop(list.indexOf("java04"));//3sop(list.indexOf("java09"));//-1sop(list.lastIndexOf("hello"));//2List<String> subList=list.subList(1, 3);

sop(subList);//hello,java03}//遍历publicstaticvoidgetIndex(){

List<String> list=newArrayList<String>();//添加元素list.add("java01");

list.add("java02");

list.add("java03");

list.add("java04");

list.set(2,"hello");//循环遍历，通过索引的方式遍历和数组一样for(intx=0;x<list.size();x++){

sop("list["+x+"]="+list.get(x));

}

}//修改publicstaticvoidset(){

List<String> list=newArrayList<String>();//添加元素list.add("java01");

list.add("java02");

list.add("java03");

list.add("java04");

list.set(2,"hello");//遍历get(list);

}//删除元素publicstaticvoidremove(){

List<String> list=newArrayList<String>();//添加元素list.add("java01");

list.add("java02");

list.add("java03");

list.add("java04");

list.remove(2);//遍历get(list);

}//添加元素publicstaticvoidadd(){

List<String> list=newArrayList<String>();//添加元素list.add("java01");

list.add("java02");

list.add("java03");//遍历get(list);//在指定位置添加list.add(1,"java09");//遍历System.out.println("========在指定位置添加后==========");

get(list);

}//遍历publicstaticvoidget(List<String>list){for(Iterator<String> it=list.iterator();it.hasNext();){

sop(it.next());

}

}publicstaticvoidsop(Object obj){

System.out.println(obj);

}

2.6、列表迭代器 listIterator

iterator，只能做判断、删除、取出，不能做其它操作

listIterator

public ListIterator<E>listIterator(int index)

返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示next的初始调用所返回的第一个元素。previous方法的初始调用将返回索引比指定索引少 1 的元素。

此实现返回ListIterator接口的直接实现，扩展了由iterator()方法返回的Iterator接口的实现。ListIterator实现依赖于底层实现列表的get(int)、set(int, E)、add(int, E)和remove(int)方法。

注意，除非重写列表的remove(int)、set(int, E)和add(int, E)方法，否则此实现返回的列表迭代器将抛出UnsupportedOperationException来响应其remove、set和add方法。

根据 (protected)modCount字段规范中的描述，在面临并发修改时，可以使此实现抛出运行时异常。

方法摘要void

add(E e)

将指定的元素插入列表（可选操作）。

boolean

hasNext()

以正向遍历列表时，如果列表迭代器有多个元素，则返回true（换句话说，如果next返回一个元素而不是抛出异常，则返回true）。

boolean

hasprevious()

如果以逆向遍历列表，列表迭代器有多个元素，则返回true。

next()

返回列表中的下一个元素。

int

nextIndex()

返回对next的后续调用所返回元素的索引。

previous()

返回列表中的前一个元素。

int

previousIndex()

返回对previous的后续调用所返回元素的索引。

void

remove()

从列表中移除由next或previous返回的最后一个元素（可选操作）。

void

set(E e)

用指定元素替换next或previous返回的最后一个元素（可选操作）。

packagecom.pb.list.demo1;importjava.util.ArrayList;importjava.util.List;importjava.util.*;publicclassListIteratorDemo {publicstaticvoidmain(String[] args) {

List<String> list=newArrayList<String>();//添加元素list.add("java01");

list.add("java02");

list.add("java03");

list.add("java04");

list.add("java05");//获取listIterator迭代器ListIterator<String> listIterator=list.listIterator();while(listIterator.hasNext()){if(listIterator.next().equals("java02")){//判断//修改listIterator.set("java007");//添加listIterator.add("hello");

}

sop(list);//倒序输出遍历while(listIterator.hasPrevious()){

sop(listIterator.previous());

}

}publicstaticvoidsop(Object obj){

System.out.println(obj);

}

2.7、Vector

packagecom.pb.list.demo1;importjava.util.ArrayList;importjava.util.Enumeration;importjava.util.List;importjava.util.Vector;publicclassVectorDemo {publicstaticvoidmain(String[] args) {

Vector<String> vector=newVector<String>();//添加元素vector.add("java01");

vector.add("java02");

vector.add("java03");

vector.add("java04");

vector.add("java05");//获取枚举Enumeration<String> en=vector.elements();while(en.hasMoreElements()){

System.out.println(en.nextElement());

}

2.8、LinkedList

packagecom.pb.list.demo1;importjava.util.LinkedList;/*** LinkedList特有方法：

* 添加元素到第一个索引位置 addFirst();

* 添加元素到最后一个索引位置 addLast();

* 获取索引为0的元素 getFirst();

* 获取索引最后的元素 getLast();

* 删除索引为0的元素 removeFirst();

* 删除索引为size()-1的元素 * removeLast();*/publicclassLinkedListDemo {publicstaticvoidmain(String[] args) {//声明一个链表集合LinkedList<String> list =newLinkedList<String>();//添加到第一个元素list.addFirst("1");

list.add("2");

list.add("3");

sop(list);//3,2,1//将元素添加到最后list.addLast("6");

list.addLast("5");

list.addLast("4");//3,2,1,6,5,4sop(list);//获取第一个元素sop(list.getFirst());//3//获取最后一个元素sop(list.getLast());//4//删除第一个元素sop(list.removeFirst());//删除最后一个sop(list.removeLast());

sop(list);//2,1,6,5/** 获取集合全部元素，不使用迭代器*/while(!list.isEmpty()) {

list.removeFirst();//list.removeLast();}

}publicstaticvoidsop(Object obj) {

System.out.println(obj);

}

removeFirst或者removeLast

public EremoveFirst()

移除并返回此列表的第一个元素。

指定者：接口Deque<E>中的removeFirst返回：

此列表的第一个元素

抛出：

NoSuchElementException- 如果此列表为空

JDK 1.6之后提供了新的方法

pollFirst或者pollLastpublic EpollFirst()

获取并移除此列表的第一个元素；如果此列表为空，则返回null。

指定者：接口Deque<E>中的pollFirst返回：此列表的第一个元素；如果此列表为空，则返回null从以下版本开始：1.6 示例

packagecom.pb.list.demo1;importjava.util.LinkedList;/*** JDK 1.6提供了新的方法

* offerFirst()，添加元素到第个

* offerLast(),添加元素到最后一位

* peekFirst()获取第一个元素

* peekLast()获取最后一个元素

* pollFirst()删除第一个元素

* pollLast()删除最后一个元素

**/publicclassLinkedListDemo1 {publicstaticvoidmain(String[] args) {//声明一个链表集合LinkedList<String> list =newLinkedList<String>();//添加到第一个元素list.offerFirst("1");

list.offerFirst("2");

list.offerFirst("3");

sop(list);//3,21//将元素添加到最后list.offerLast("6");

list.offerLast("5");

list.offerLast("4");//3,2,1,6,5,4sop(list);//获取第一个元素sop(list.peekFirst());//3//获取最后一个元素sop(list.peekLast());//4//删除第一个元素sop(list.pollFirst());//删除最后一个sop(list.pollLast());

sop(list);//2,1,6,5/** 获取集合全部元素，不使用迭代器*/while(!list.isEmpty()) {

list.pollFirst();//list.pollLast()}

}publicstaticvoidsop(Object obj) {

System.out.println(obj);

}

示例：

packagecom.pb.list.demo1;importjava.util.LinkedList;/*** 使用LinkedList模拟一个堆栈或者队列数据结构

* 堆栈：先进后出

* 队列：先进先出

**/publicclassLinkedListDemo2 {publicstaticvoidmain(String[] args) {

Que q=newQue();

q.myAdd("java01");

q.myAdd("java02");

q.myAdd("java03");

q.myAdd("java04");

q.myAdd("java05");while(!q.isNUll()){//输出System.out.println(q.myGet());

}

}classQue{privateLinkedList list=null;publicQue(){

list=newLinkedList();

}//判断是不是NULLpublicbooleanisNUll(){returnlist.isEmpty();

}//添加publicvoidmyAdd(Object obj){

list.offerFirst(obj);

}//删除publicObject myGet(){returnlist.pollLast();//先出//return list.pollFirst();}

}

示例，去除list的重复元素

packagecom.pb.list.demo1;importjava.util.ArrayList;importjava.util.Iterator;/*** 去除ArrayList中的重复元素

*@authorAdministrator

**/publicclassArrayListDemo1 {publicstaticvoidmain(String[] args) {

ArrayList list=newArrayList();

list.add("java01");

list.add("java02");

list.add("java03");

list.add("java019");

System.out.println(getSingle(list));

}publicstaticArrayList getSingle(ArrayList list){

ArrayList tempList=newArrayList();for(Iterator it=list.iterator();it.hasNext();){

Object obj=it.next();if(!tempList.contains(obj)){

tempList.add(obj);

}

}returntempList;

}

示例，去除list的重复对象

packagecom.pb.list.demo1;publicclassPerson {privateString name;privateintage;//重写equals@Overridepublicbooleanequals(Object obj) {if(!(objinstanceofPerson)){returnfalse;

}

Person p=(Person)obj;returnthis.name.equals(p.name)&&this.age==p.age;

}publicPerson() {super();//TODO Auto-generated constructor stub}publicPerson(String name,intage) {super();this.name =name;this.age =age;

}publicString getName() {returnname;

}publicvoidsetName(String name) {this.name =name;

}publicintgetAge() {returnage;

}publicvoidsetAge(intage) {this.age =age;

}publicvoidshow(){

System.out.println(this.name+"........"+this.age);

}

packagecom.pb.list.demo1;importjava.util.ArrayList;importjava.util.Iterator;/*** 去除ArrayList中的重复元素

*@authorAdministrator

**/publicclassArrayListDemo1 {publicstaticvoidmain(String[] args) {

Person p1=newPerson("张三",19);

Person p2=newPerson("张三",19);

Person p3=newPerson("李四",23);

Person p4=newPerson("李四",23);

Person p5=newPerson("王五",33);

Person p6=newPerson("王五",23);

Person p7=newPerson("赵六",18);

ArrayList<Person> list=newArrayList<Person>();

list.add(p1);

list.add(p2);

list.add(p3);

list.add(p4);

list.add(p5);

list.add(p6);//遍历去掉重复后的for(Person p:getSingle(list)){

p.show();

}

}publicstaticArrayList<Person> getSingle(ArrayList<Person>list){

ArrayList<Person> tempList=newArrayList<Person>();for(Iterator<Person> it=list.iterator();it.hasNext();){

Person p=it.next();if(!tempList.contains(p)){//contains也是调用对象equals方法tempList.add(p);

}

}returntempList;

}

2.9、三种集合区别

ArrayList：底层的数据结构使用是数组结构,遍历快，增、删、改，慢,线程不同步

LinkedList：底层的数据结构使用链表数据结构，遍历慢，增、删、改，快，

Vector:底层的数据结构使用是数组结构,线程同步的，被ArrayList替代了。

三、Set3.1、List和Set区别

List:元素是有序的，元素可以重复，该集合体系有索引

Set:元素是无序，元素不可以重复

一个不包含重复元素的 collection。更确切地讲，set 不包含满足e1.equals(e2)的元素对e1和e2，并且最多包含一个 null 元素。

3.2、常见子类

HashSet--哈希表,TreeSet

3.3、功能方法

Set的方法和Collection一样，使用方式也一样

packagecom.pb.list.demo1;publicclassPerson {privateString name;privateintage;//重写hashCode@OverridepublicinthashCode() {

System.out.println("========hashCode");returnname.hashCode()+age*39;

}//重写equals@Overridepublicbooleanequals(Object obj) {if(!(objinstanceofPerson)){returnfalse;

}

Person p=(Person)obj;

System.out.println(p.name+"========equals"+p.age);returnthis.name.equals(p.name)&&this.age==p.age;

}publicPerson() {super();//TODO Auto-generated constructor stub}publicPerson(String name,intage) {super();this.name =name;this.age =age;

}publicString getName() {returnname;

}publicvoidsetName(String name) {this.name =name;

}publicintgetAge() {returnage;

}publicvoidsetAge(intage) {this.age =age;

}publicvoidshow(){

System.out.println(this.name+"........"+this.age);

}

packagecom.pb.list.demo1;importjava.util.HashSet;importjava.util.Iterator;publicclassDemo1 {publicstaticvoidmain(String[] args) {

Person p1=newPerson("张三",19);

Person p2=newPerson("李四",20);

Person p3=newPerson("张三",19);

Person p4=newPerson("李四",20);

Person p5=newPerson("五一",19);

Person p6=newPerson("五一",19);

HashSet<Person> set=newHashSet<Person>();

set.add(p6);

set.add(p5);

set.add(p4);

set.add(p3);

set.add(p2);

set.add(p1);

Iterator<Person> iterator=set.iterator();while(iterator.hasNext()){

Person p=iterator.next();

p.show();

}

========hashCode========hashCode

五一========equals19========hashCode========hashCode========hashCode

李四========equals20========hashCode

张三========equals19

李四........20张三........19五一........19

ArrayList:判断元素是否存或者删除依赖的方法equals()方法

Set:判断元素是否存或者删除，依赖的方法hashCode()和equals()方法,先判断hashCode如果有再判断equals