集合的由来
对象用于封装特有数据，对像多了需要存储，如果对象的个数不确定，就使用集合容器进行存储。
集合特点
- 用于存储对象的容器
- 集合的长度是可变的
- 集合中不可以存储基本数据类型值
集合容器因为内部的数据结构不同，有多种具体容器。不断的向上抽取，就形成了集合框架。
框架的顶层Collection接口
Collection的常见方法：
添加
boolean add(Object obj);
boolean addAll(Collection coll);删除
boolean remove(Objetc obj);
boolean removeAll(Collection coll);判断
boolean contains(Object obj);
boolean containsAll(Object coll);
boolean isEmpty();//判断集合中是否有元素获取
int size();
Iterator iterator();//取出元素的方式，迭代器该对象必须依赖于具体容器，因为每一个容器的数据结构都不同，所以该迭代器对象是在容器中进行内部实现的。对于使用容器者而言，具体实现不重要，只要通过容器获取该实现的迭代器对象即可，也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。其他
boolean retainAll(Collection coll);//取交集
Object[] toArray();//将集合转成数组代码演示
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args){
Collection c1=new ArrayList();
Collection c2=new ArrayList();
show(c1,c2);
}
public static void show(Collection c1,Collection c2){
//给c1添加元素
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");
//给c2添加元素
c2.add("abc2");
c2.add("abc3");
c2.add("abc7");
//演示addAll
// c1.addAll(c2);将c2对象添加到c1中
// c1.addAll(c2);//将c2中的元素添加到c1中
//演示removeAll
//c1.remove(c2);将c1中的c2对象删除
//c1.removeAll(c2);//将两个集合相同元素从调用removeAll的集合中删除
//演示containsAll
//boolean b=c1.contains(c2);//c1中是否包含c2对象
//boolean b=c1.containsAll(c2);//c1是否包含c2中的所有元素
//c1.retainAll(c2);//取交集，保留和指定集合相同的元素，删除不同的元素，和removeAll功能相反
System.out.println("c1"+c1);
System.out.println("c2"+c2);
}
}
Iterator迭代器
只有三个方法
boolean hasNext();如果仍有元素可以迭代，则返回true
next();返回迭代的下一个元素
void remove();从迭代器指向的collection中一处迭代器返回的最后一个元素import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class InteratorDemo {
public static void main(String[] args){
Collection coll=new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
System.out.println(coll);
//使用了Collection中的iterator()方法，调用集合中的迭代器方法，是为了获取集合中的迭代器对象
/*Iterator it=coll.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}*/
for (Iterator it=coll.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
List集合和Set集合的特点
List：有序,(存入和取出的顺序一致，)元素都有索引(角标)，元素可以重复。
Set：元素不能重复，无序。
List集合
List特有的常见方法
有一个共性特点，就是都可以操作角标
1.添加
void add(index,element);
void add(index,collection);2.删除
Object remove(index);3.修改
Object set(index,element);4.获取
Object get(index);
int indexOf(Object);
int lastIndexOf(object);
List subList(from,to);演示
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args){
List list=new ArrayList();
show(list);
}
public static void show(List list){
//添加元素
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println(list);
//插入元素
list.add(1,"abc9");
System.out.println(list);
//删除元素
System.out.println("remove:"+list.remove(2));
//修改元素
System.out.println("set:"+list.set(1,"abc8"));
//获取元素
System.out.println("get:"+list.get(0));
//获取子列表
System.out.println("sublist:"+list.subList(1,3));
System.out.println(list);
}
}
list特有的取出元素方法之一
public class ListDemo2 {
public static void main(String[] args){
List list=new ArrayList();
show(list);
}
public static void show(List list){
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
Iterator it=list.iterator();
while (it.hasNext()){
System.out.println("next"+it.next());
}
//List特有的取出元素方法之一
for(int x=0;x<list.size();x++){
System.out.println("get"+list.get(x));
}
}
}
ListIterator接口(列表迭代器)
List的子接口，包含比List更多的方法，在迭代过程中，可以对元素进行增删改查
public class ListDemo2 {
public static void main(String[] args){
List list=new ArrayList();
show(list);
}
public static void show(List list) {
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
/* Iterator it = list.iterator();
while (it.hasNext()) {
Object obj = it.next();//java.util.ConcurrentModificationException
//在迭代器过程中，不要使用集合操作元素，容易出现异常
//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作
if (obj.equals("abc2")) {
list.add("abc9");
} else
System.out.println("next:" + obj);
}
System.out.println(list);*/
ListIterator it=list.listIterator();//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查
//注意：只有list集合具备该迭代功能
while (it.hasNext()){
Object obj=it.next();
if (obj.equals("abc2")){
it.set("abc9");
}
}
System.out.println(list);
System.out.println(it.previous());//逆向遍历
}
}
List常用子类的特点
线程不同步（线程不安全）
Vector：内部是数组数据结构，是同步的。增删，查询都很慢。
ArrayList：内部是数组数据结构，是不同步的。代替了Vector。查询的速度快。
LinkedList：内部是链表数据结构，是不同步的。增删元素的速度非常快。
Vector集合
boolean hasMoreElements() //测试此枚举是否包含更多元素
E nextElement() //如果此枚举对象至少有一个要提供的元素，则返回此枚举的下一个元素 public static void main(String[] args){
Vector v=new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
Enumeration enumeration=v.elements();
while (enumeration.hasMoreElements()){
System.out.println(enumeration.nextElement());
}
Iterator it=v.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}LinkedList集合
void addFirst(E e) //在该列表开头插入指定的元素
void addLast(E e) //将指定的元素追加到此列表的末尾
E removeFirst() //从此列表中删除并返回第一个元素
E removeLast() //从此列表中删除并返回最后一个元素
E getFirst() //返回此列表中的第一个元素
E getLast() //返回此列表中的最后一个元素
E pollFirst() //检索并删除此列表的第一个元素，如果此列表为空，则返回 null
E pollLast() //检索并删除此列表的最后一个元素，如果此列表为空，则返回 null
E peekFirst() //检索但不删除此列表的第一个元素，如果此列表为空，则返回 null
E peekLast() //检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null
boolean offerFirst(E e) //在此列表的前面插入指定的元素
boolean offerLast(E e) //在该列表的末尾插入指定的元素
public static void main(String[] args){
LinkedList link=new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
while (!link.isEmpty()){
System.out.println(link.removeLast());
}
/* Iterator it=link.iterator();
while (it.hasNext()){
System.out.println(it.next());
}*/
}使用LinkList来模拟一个堆栈或者队列数据结构
class DuiLie{
private LinkedList link;
DuiLie(){
link=new LinkedList();
}
/*队列添加元素的功能*/
public void myAdd(Object obj){
link.addLast(obj);
}
public Object myGet(){
return link.removeFirst();//removeLast就是堆栈
}
public boolean isNull(){
return link.isEmpty();
}
}ArrayList集合
存储自定对象
public static void main(String[] args){
ArrayList al=new ArrayList();
al.add(new Person("lisi1",21));
al.add(new Person("lisi2",21));
al.add(new Person("lisi3",21));
al.add(new Person("lisi4",21));
Iterator it=al.iterator();
while (it.hasNext()){
Person p=(Person) it.next();
System.out.println(p.getName()+"--"+p.getAge());
/*System.out.println(((Person)it.next()).getName());*/
}判断两个元素是否相同
运用contains方法判断元素，实际上就是equals方法（在Person对equals方法进行重写）
public class Person {
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
/*@Override
public int hashCode(){ //重写hashCode比较方法
System.out.println(this+".....hashCode");
return name.hashCode()+age;
}*/
@Override
public boolean equals(Object obj){//重写equals比较方法
if (this==obj){
return true;
}
if (!(obj instanceof Person))
throw new ClassCastException("错误类型");
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
}
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest2 {
public static void main(String[] args){
ArrayList al=new ArrayList();
al.add(new com.monfolld.p.bean.Person("lisi1",21));
al.add(new com.monfolld.p.bean.Person("lisi2",22));
al.add(new com.monfolld.p.bean.Person("lisi3",23));
al.add(new com.monfolld.p.bean.Person("lisi4",21));
al.add(new com.monfolld.p.bean.Person("lisi3",21));
al.add(new com.monfolld.p.bean.Person("lisi4",21));
System.out.println(al);
al=getSingleElement(al);
System.out.println(al);
}
public static ArrayList getSingleElement(ArrayList al){
//1.定义一个临时容器
ArrayList temp=new ArrayList();
//2.迭代al集合
Iterator it=al.iterator();
while (it.hasNext()){
Object obj=it.next();
//3.判断被迭代的元素是否存在临时容器存在
if (!temp.contains(obj)){
temp.add(obj);
}
}
return temp;
}Set集合
Set接口中的方法和Collection一致，元素不能重复，无序。
HashSet集合
内部数据结构是哈希表，是不同步的，根据自己算法确定元素位置
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法， 就直接存储到哈希表中。如果对象的hashCode值相同， 那么要再次判断对象的equals方法是否为true。
如果为true, 视为相同元素，不存。如果为false， 那么视为不同元素，就进行存储。
public static void main(String[] args){
HashSet hs=new HashSet();
hs.add("haha");
hs.add("hehe");
hs.add("heihei");
hs.add("xixi");
hs.add("xixi");
Iterator it=hs.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
/*结果：
haha
heihei
hehe
xixi*/哈希表确定元素是否相同
1.判断的是两个元素的哈希值是否相同，如果相同，再判断两个对象的内容是否相同。
2.判断哈希值相同，其实判断的是对象的hashCode方法。判断内容相同，用的是equals方法。
HashSet存储自定义对象
package com.monfolld.p.bean;
public class Person {
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode(){ //重写hashCode比较方法
System.out.println(this+".....hashCode");
return name.hashCode()+age;
}
@Override
public boolean equals(Object obj){//重写equals比较方法
System.out.println(this+".....equals");
if (this==obj){
return true;
}
if (!(obj instanceof Person))
throw new ClassCastException("错误类型");
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
}
public static void main(String[] args){
HashSet hs=new HashSet();
hs.add(new com.monfolld.p.bean.Person("list9",24));
hs.add(new com.monfolld.p.bean.Person("list7",27));
hs.add(new com.monfolld.p.bean.Person("list1",22));
hs.add(new com.monfolld.p.bean.Person("list9",29));
hs.add(new com.monfolld.p.bean.Person("list9",29));
Iterator it=hs.iterator();
while (it.hasNext()){
Person p=(Person) it.next();
System.out.println(p.getName()+"..."+p.getAge());
}
}LinkedHashSet集合
哈希表和链表实现了Set接口，具有可预测的迭代次序。 这种实现不同于HashSet，它维持于所有条目的运行双向链表。 该链表定义了迭代排序，它是将元素插入集合（插入顺序 ） 的顺序 。
有序且唯一
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class HashSetDemo {
public static void main(String[] args){
HashSet hs=new LinkedHashSet();
hs.add("haha");
hs.add("hehe");
hs.add("heihei");
hs.add("xixi");
hs.add("xixi");
Iterator it=hs.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}TreeSet集合
可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是比较方法的返回值是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元素就需要实现Comparable接口，覆盖compareTo方法。
以Person对象的年龄进行从小到大的排序
package com.monfolld.p.bean;
public class Person implements Comparable{
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
@Override
public int compareTo(Object o){
Person p=(Person)o;
/*if (this.age>p.age)
return 1;
if (this.age<p.age)
return -1;
else
return this.name.compareTo(p.name);*/
int temp=this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;
}
}
public static void main(String[] args){
TreeSet ts=new TreeSet();
/*以Person对象的年龄进行从小到大的排序*/
ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("wangwu",23));
ts.add(new Person("zhaoliu",25));
ts.add(new Person("zhouqi",25));/**/
Iterator it=ts.iterator();
while (it.hasNext()){
Person p=(Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
/*结果：
lisi:21
wangwu:23
zhaoliu:25
zhouqi:25
zhangsan:28*/如果不要按照对象中具备的自然顺序进行排序，如果对象不具备自然顺序，怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备功能，定义一个实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。
/*创建一个根据Person类的name进行排序的比较器*/
public class ComparatorByName implements Comparator {
@Override
public int compare(Object o1,Object o2){
Person p1=(Person)o1;
Person p2=(Person)o2;
int temp=p1.getName().compareTo(p2.getName());
return temp==0?p1.getAge()-p2.getAge():temp;
}
} public static void main(String[] args){
TreeSet ts=new TreeSet(new ComparatorByName());//优先级高
ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("wangwu",23));
ts.add(new Person("zhaoliu",25));
ts.add(new Person("zhouqi",25));/**/
Iterator it=ts.iterator();
while (it.hasNext()){
Person p=(Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
/*结果：
lisi:21
wangwu:23
zhangsan:28
zhaoliu:25
zhouqi:25*/根据长度比较
public class comparatorByLen implements Comparator {
@Override
public int compare(Object o1,Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
int temp = s1.length() - s2.length();
return temp == 0 ? s1.compareTo(s2) : temp;
}
}
public static void main(String[] args){
TreeSet ts=new TreeSet(new comparatorByLen());
ts.add("aaaaa");
ts.add("zz");
ts.add("nbaq");
ts.add("cba");
ts.add("abc");
Iterator it=ts.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
