import java.util.ArrayList;
class
CollectionDemo
{
public static void main(String[] args)
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);容器内添加的对象是任意类型的，类型不确定，需要用父类，此处是多态
al.add("java02");
al.add("java03");
al.add("java04");
//打印原集合。
sop("原集合:"+al);//输出：原集合:[java01, java02, java03, java04]
//2，删除元素。
al.remove("java02");//输出：remove后集合:[java01, java03, java04]
sop("remove后集合:"+al);
al.clear();//清空集合。
sop("clear后集合:"+al);//输出：clear后集合:[]
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

判断:

</pre><pre name="code" class="java">import java.util.ArrayList;
class
CollectionDemo
{
public static void main(String[] args)
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);容器内添加的对象是任意类型的，类型不确定，需要用父类，此处是多态
al.add("java02");
al.add("java03");
al.add("java04");
sop("原集合:"+al);//输出：原集合:[java01, java02, java03, java04]
//2，删除元素。
al.remove("java02");//输出：remove后集合:[java01, java03, java04]
sop("remove后集合:"+al);
al.clear();//清空集合。
sop("clear后集合:"+al);//输出：clear后集合:[]
//3，判断元素。
sop("java03是否存在:"+al.contains("java03"));//输出：java03是否存在:false
sop("集合是否为空？"+al.isEmpty());//输出：集合是否为空？true（此时集合长度为零）
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

获取交集:

import java.util.ArrayList;
class
CollectionDemo
{
public static void main(String[] args)
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al1 = new ArrayList();
//al1添加元素
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
//al2添加元素
al2.add("java01");
al2.add("java02");
al2.add("java08");
al2.add("java09");
al2.add("java10");
//al1.retainAll(al2)
al1.retainAll(al2);
sop("al1:" + al1);//输出：al1:[java01, java02]
sop("al2:" + al2);//输出：al2:[java01, java02, java08, java09, java10]
//al2.retainAll(al1)
al2.retainAll(al1);
sop("al2:" + al2);//输出：al2:[java01, java02]
}

取出元素:

迭代器接口Iterator

迭代的常见操作

import java.util.ArrayList;
import java.util.Iterator;
class
CollectionDemo
{
public static void main(String[] args)
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//al添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//利用迭代器获取元素的基本方法
Iterator it = al.iterator();//获取迭代器，取出集合中的元素
//接口型引用只能指向自己的子类对象，而且该对象并不是被new()出来的，是通过al这个ArrayList调用了iterator()方法获取出来的
//sop(it.next());//java01
//sop(it.next());//java02
//sop(it.hasNext());//true
while(it.hasNext()){//iterator中的hasNext方法，只要集合中还有下一个元素，就返回真
sop(it.next());//iterator中的next方法，取出下一个元素，并通过sop打印
}
/*
输出：
java01
java02
java03
java04
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*
while代码块如果用for来写，格式如下：
for(Iterator it = al.iterator(); it.hasNext() ; )
{
System.out.println(it.next());
}
使用for来写，避免了循环结束后it还在内存中
*/

List

体系概述

List特有方法

增加：

import java.util.*;
class ListIteratorDemo{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//新建一个ArrayList，并添加3个元素
ArrayList aL = new ArrayList();
aL.add("java01");
aL.add("java02");
aL.add("java03");
sop(aL);
/*
//在迭代过程中，准备添加或者删除元素。
Iterator it = al.iterator();//此时把元素的引用又取到迭代器中去了
//操作元素既可以用add，也可以用迭代器，但是不能同时使用，会发生ConcurrentModificationException异常
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java02"))//调用Object类的equals方法
//al.add("java008");
it.remove();//将java02的引用从集合中删除了。使用了Iterator的remove功能，不过移除的仅仅是集合中元素的引用
//但是Iterator中没有add功能，要用迭代器来添加元素，考虑用ListIterator
sop("obj="+obj);//输出：obj1=java01 n obj2=java02 n obj3=java03,元素的引用移除了，元素还在内存中，并还在被obj使用，java02还能打出
}
sop(al);//输出：[java01,java03]，移除后al的结果
*/
//新建一个ListIterator对象
//使用ListIterator的add方法
for(ListIterator li = aL.listIterator(); li.hasNext() ; )
{
Object obj = li.next();
if(obj.equals("java02"))
li.add("java009");
}
sop(aL);//输出：[java01, java02, java009, java03]，在java02这个元素后面插入一个java009的新元素
//使用ListIterator的set方法
for(ListIterator li = aL.listIterator(); li.hasNext() ;)//如果使用while的方式，则hasnext()直接为flase，因为li还在内存中
{
Object obj = li.next();
if(obj.equals("java02"))
li.set("java006");//把java02的位置替换为Java006
}
sop(aL);//输出：[java01, java006, java009, java03]
//使用ListIterator的hasPrevious、previous方法
ListIterator li = aL.listIterator();
while(li.hasNext())
{
sop("next::"+li.next());
}
while(li.hasPrevious())
{
sop("pres::" + li.previous());
/*
pres::java03
pres::java009
pres::java006
pres::java01
*/
}
}
}

Enumeration:Vector

LinkedList特有方法

import java.util.*;
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
//addLast方法：尾端插入
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
sop(link);//输出：[java01, java02, java03, java04]
//addFirst方法：首端插入
link.addFirst("java11");
link.addFirst("java22");
link.addFirst("java33");
link.addFirst("java44");
sop(link);//输出：[java44, java33, java22, java11, java01, java02, java03, java04]
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

获取：

package collection;
import java.util.*;
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.add("java01");
link.add("java02");
link.add("java03");
link.add("java04");
sop(link);//输出：[java01, java02, java03, java04]
//getFisrt
sop(link.getFirst());//输出：java01
//getLast
sop(link.getLast());//输出：java04
//removeFirst
while(!link.isEmpty()){
sop(link.removeFirst());
/*
java01
java02
java03
java04
*/
}
//removeLast
while(!link.isEmpty()){//仅为演示用，实际过程中，此处link已经是空的，不会输出
sop(link.removeLast());
}
/*
java04
java03
java02
java01
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

package collection;
import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。
List集合判断元素是否相同，依据是元素的equals方法。
*/
class Person
{
private String name;
private int age;
Person(String name,int age)//构造器
{
this.name = name;
this.age = age;
}
//开发时使用setter和getter
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//equals方法：判断对象是否相同
public boolean equals(Object obj)//此处的equals对象的equals方法（上帝的方法），根据自定义的要求，复写该equals方法
//在容器比较元素是否相同，使用的是equals方法，用对象的equals和另一个对象在比较
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;//向下转型
System.out.println(this.name+"....."+p.name);
/*
程序输出：主动比较者（this）...被比较者(obj)
lisi02.....lisi01
lisi04.....lisi01
lisi04.....lisi02
lisi03.....lisi01
lisi03.....lisi02
lisi03.....lisi04
lisi04.....lisi01
lisi04.....lisi02
lisi04.....lisi04
lisi03.....lisi01
lisi03.....lisi02
lisi03.....lisi04
lisi03.....lisi03
*/
return this.name.equals(p.name) && this.age == p.age;//返回真就说明相同，返回假就说明不同
//此处的equals是调用字符串的equals方法
}
}
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();//ArrayList容器不知道元素相同的条件
al.add(new Person("lisi01",30));
//其实在存的时候存的是al.add(Object obj);，只有Object才能接收任意对象
//把Person往里面传的时候，其实是这样：Object obj = new Person("lisi01",30);类型被提升了
//使用next时，返回的是Object,Object中没有Person特有的方法，如果还想要再得到Person类中的方法，需要向下转型
al.add(new Person("lisi02",32));
al.add(new Person("lisi04",35));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35));
//sop(al);
//使用singleElement(al)方法后，去掉了重复元素
al = singleElement(al);
sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。
Iterator it = al.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();//next()返回的是已经被提升的类型，需要子类对象特有的方法（此处如getName）时，需要先向下转型
/*
其实是两句话的简化
Object obj = it.next();
Person p =(Person)obj; 意思就是把obj变成Person类型，然后赋给p
*/
sop(p.getName()+"::"+p.getAge());
}
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器。
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newAl.contains(obj))
//contains方法在判断是否存在该元素的时候，其实是在用对象的equals方法在和对象进行比较，看对象与对象是否相同
//如果要自定义新的equals规则，需要复写对象的equals方法
//1.lisi01先传入到contains的obj中
//2.lisi01被添加进newA1这个集合中
//3.lisi02被传入到contains的obj中
//4.程序跳转到public boolean equals(Object obj)，开始进行equals的比较
//5.因为第一个对象lisi01并没有其他对象与之比较，所以直接被传入到newAl中，而第二个对象lisi02则需要调用equals方法与第一个传入的对象lisi01进行比较
//6.equals在Object类的源码中的语句是：public boolean equals(Object obj) {return (this == obj)}，第一次比较时，obj是lisi01,this是lisi02
//7.因为newAl.contains(obj)第一次比较时，相当于lisi02.equals(lisi01)，因为lisi01是先存在的，用后来的和先来的比较
//8.那么lisi01就传入public boolean equals(lisi01)
newAl.add(obj);
}
return newAl;
}
}

在HashSet中存入自定义对象

package collection;
import java.util.*;
/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。
*/
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//创建一个HashSet
HashSet hs = new HashSet();
//在HashSet中存入元素
hs.add(new Person4("a1",11));
hs.add(new Person4("a2",12));
hs.add(new Person4("a3",13));
hs.add(new Person4("a2",12));//重复的元素
//sop("a1:"+hs.contains(new Person("a2",12)));
//hs.remove(new Person("a4",13));
//取出HashSet中的元素
Iterator it = hs.iterator();
while(it.hasNext())
{
Person4 p = (Person4)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person4
{
private String name;
private int age;
Person4(String name,int age)
{
this.name = name;
this.age = age;
}
//复写Object类的hashCode方法
public int hashCode()
{
System.out.println(this.name+"....？hashCode");
return name.hashCode()+age*37;//如果return了固定值，如return 60，那么所有元素hashcode相同，会不断调用equals方法，效率较低
//name.hashCode()调用了String复写Object类的hashCode方法
//字符串的hashCode的计算公式为：s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
//age乘以一个数是为了防止这样的情况发生:Stringobj1.hashCode() + Stringobj2.age = Stringobj2.hashCode() + Stringobj1.age
}
//建立Person对象自己的hashCode
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写Object类的equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Person4))
return false;
Person4 p = (Person4)obj;
System.out.println(this.name+"...equals？.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
/*
输出结果：
//System.out.println(this.name+"....？hashCode");
a1....？hashCode
a2....？hashCode
a3....？hashCode
a2....？hashCode
//System.out.println(this.name+"...equals？.."+p.name);
a2...equals？..a2
//sop(p.getName()+"::"+p.getAge());
a3::13
a1::11
a2::12
*/

TreeSet

底层实现及概念

与HashSet相比最大的特点：

可以对Set集合中的元素进行排序。

实现TreeSet排序的两种方式

1，让元素自身具备比较性

元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。

2，让集合自身具备比较性

当元素自身不具备比较性时，或、比较性并非所需。这时就要让集合自身具备比较性。在集合初始化时，就有了比较方式。

TreeSet底层数据结构：红黑树

package collection;
/*
需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的"年龄"进行排序。
*/
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
//ts.add(new Student("lisi007",20));
//如果比完此处的主要条件：年龄之后，不再比较一下次要条件：姓名，那么当年龄相同而姓名不同的人存进来以后，将不会被存入
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
//告诉TreeSet用哪种方式进行排
//TreeSet本身需要进行排序，但是它并不知道以怎样的方式排，如果不让存入的对象具备比较性，会产生ClassCastException
//让元素自身具备比较性：1.实现Comparable接口
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
//让元素自身具备比较性：2.复写compareTo方法
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;//向下转型
System.out.println(this.name+"....compareto....."+s.name);
if(this.age>s.age)
return 1;//返回负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
if(this.age==s.age)
{
return this.name.compareTo(s.name);//比较完主要条件之后再比较次要条件
//用compareTo方法之后，当年龄相同时，还会按照姓名的顺序进行排序输出
//String类中本身就包含compareTo方法
/*
按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。
按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。
如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
如果这两个字符串相等，则结果为 0；compareTo
只在方法 equals(Object) 返回 true 时才返回 0。
*/
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

class TreeSetOptDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student2("lisi02",17));
ts.add(new Student2("lisi007",20));
ts.add(new Student2("lisi09",19));
ts.add(new Student2("lisi08",19));
ts.add(new Student2("lisi06",19));
//如果比完此处的主要条件：年龄之后，不再比较一下次要条件：姓名，那么当年龄相同而姓名不同的人存进来以后，将不会被存入
Iterator it = ts.iterator();
while(it.hasNext())
{
Student2 stu = (Student2)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
//告诉TreeSet用哪种方式进行排
//TreeSet本身需要进行排序，但是它并不知道以怎样的方式排，如果不让存入的对象具备比较性，会产生ClassCastException
//让元素自身具备比较性：1.实现Comparable接口
class Student2 implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student2(String name,int age)
{
this.name = name;
this.age = age;
}
//让元素自身具备比较性：2.复写compareTo方法
public int compareTo(Object obj)
{
return 1;//1代表后存入的对象总是比先存入的对象大，取的时候默认方式是从小到大取出
//结果是按照存入的顺序输出
/*
return1输出结果：
lisi02...17
lisi007...20
lisi09...19
lisi08...19
lisi06...19
return-1输出结果：
lisi06...19
lisi08...19
lisi09...19
lisi007...20
lisi02...17
*/
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

常用操作方法