集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定,就使用集合容器进行存储。
集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。
框架的顶层Collection接口：java.util
Collection的常见方法：
1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):
2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();
3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。
package cn.itcast.p3.collection.demo; import java.util.ArrayList;
import java.util.Collection; public class CollectionDemo { public static void main(String[] args) {
Collection coll = new ArrayList(); show(coll); } public static void show(Collection coll){ //1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll); //2，删除元素。remove
// coll.remove("abc2");//会改变集合的长度 //清空集合.
// coll.clear(); System.out.println(coll.contains("abc3")); System.out.println(coll); } }
package cn.itcast.p3.collection.demo; import java.util.ArrayList;
import java.util.Collection; public class CollectionDemo { /**
* @param args
*/
public static void main(String[] args) {
Collection coll = new ArrayList(); 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("abc1");
c2.add("abc2");
c2.add("abc3");
c2.add("abc4");
c2.add("abc5"); System.out.println("c1:"+c1);
System.out.println("c2:"+c2); //演示addAll // c1.addAll(c2);//将c2中的元素添加到c1中。 //演示removeAll
// boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
// System.out.println("removeAll:"+b); //演示containsAll
// boolean b = c1.containsAll(c2);
// System.out.println("containsAll:"+b); //演示retainAll
boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
//和removeAll功能相反 。
System.out.println("retainAll:"+b);
System.out.println("c1:"+c1);
}
}
4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！
package cn.itcast.p3.collection.demo; import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; public class IteratorDemo {
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());
}
}
}
5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。
-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。
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);
list集合是可以完成对元素的增删改查。
package cn.itcast.p4.list.demo;
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("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, 2));
System.out.println(list);
}
}
package cn.itcast.p4.list.demo; import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator; public class ListDemo2 { /**
* @param args
*/
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));
}
}
}
public class ListDemo2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println("list:"+list);
//Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。
ListIterator it = list.listIterator();
//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查。
//注意：只有list集合具备该迭代功能.
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc2")){
it.set("abc9");
}
}
// System.out.println("hasNext:"+it.hasNext());
// System.out.println("hasPrevious:"+it.hasPrevious());
//逆向遍历
while(it.hasPrevious()){
System.out.println("previous:"+it.previous());
}
System.out.println("list:"+list);
}
List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！(不用了)
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
Vector举例：
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println("nextelment:"+en.nextElement());
}
//Enumeration接口与Iterator接口功能是重复的。
Iterator it = v.iterator();
while(it.hasNext()){
System.out.println("next:"+it.next());
}
}
}
LinkedList举例：查api
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
// System.out.println(link);
// System.out.println(link.getFirst());//获取第一个但不删除。
// System.out.println(link.getFirst());
// System.out.println(link.removeFirst());//获取元素但是会删除。
// System.out.println(link.removeFirst());
while(!link.isEmpty()){
System.out.println(link.removeLast());
}
System.out.println(link);
// Iterator it = link.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
}
}
ArrayList示例：
public class ArrayListTest {
public static void main(String[] args) {
Person p1 = new Person("lisi1",21);
ArrayList al = new ArrayList();
al.add(p1);
al.add(new Person("lisi2",22));
al.add(new Person("lisi3",23));
al.add(new Person("lisi4",24));
Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
System.out.println(p.getName()+"--"+p.getAge());
}
}
}
Set:
元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。
示例：
package cn.itcast.p.bean;
public class Person extends Object{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
// System.out.println(this+".......hashCode");
return name.hashCode()+age*27;
}
@Override
public boolean equals(Object obj) {
if(this == obj)
return true;
if(!(obj instanceof Person))
throw new ClassCastException("类型错误");
// System.out.println(this+"....equals....."+obj);
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.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;
}
}
package cn.itcast.p4.hashset.test;
import java.util.HashSet;
import java.util.Iterator;
import cn.itcast.p.bean.Person;
/*
* 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。
*/
public class HashSetTest {
public static void main(String[] args) {
HashSet hs = new HashSet();
/*
* HashSet集合数据结构是哈希表，所以存储元素的时候，
* 使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同。
*
*/
hs.add(new Person("lisi4",24));
hs.add(new Person("lisi7",27));
hs.add(new Person("lisi1",21));
hs.add(new Person("lisi9",29));
hs.add(new Person("lisi7",27));
Iterator it = hs.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p);
// System.out.println(p.getName()+"...."+p.getAge());
}
}
}
有序还唯一用子类：LinkedHashSet
|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
package cn.itcast.p.bean;
public class Person implements Comparable {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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;
//按年龄排序
int temp = this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;
//按姓名排序
// int temp = this.name.compareTo(p.name);
// return temp==0?this.age-p.age:temp; }
}
package cn.itcast.p5.treeset.demo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p.bean.Person;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("zhouqi",29));
ts.add(new Person("zhaoliu",25));
ts.add(new Person("wangu",24));
Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
} }
}
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：（常用）
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。
package cn.itcast.p5.comparator;
import java.util.Comparator;
import cn.itcast.p.bean.Person;
/**
* 创建了一个根据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;
}
}
package cn.itcast.p5.treeset.demo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p.bean.Person;
import cn.itcast.p5.comparator.ComparatorByName;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new ComparatorByName());
/*
* 以Person对象年龄进行从小到大的排序。
*
*/
ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("zhouqi",29));
ts.add(new Person("zhaoliu",25));
ts.add(new Person("wangu",24));
Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}
package cn.itcast.p5.comparator;
import java.util.Comparator;
public class ComparatorByLength 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;
}
}
package cn.itcast.p5.treeset.test;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p5.comparator.ComparatorByLength;
/*
* 对字符串进行长度排序。
*
* "20 18 -1 89 2 67"
*/
public class TreeSetTest {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new ComparatorByLength());
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());
}
}
}
if(this.hashCode()== obj.hashCode() && this.equals(obj))
哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。
2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。
注意：如果哈希值不同，是不需要判断equals。
完毕..