集合类：用于存储对象，集合长度可变，集合可存储不同类型对象。
1.add方法的参数类型是Object，以便接受任意类型对象。
2.集合中存储的都是对象的引用即地址，而不是对象实体。
3什么是迭代器呢？
其实就是集合的取出元素的方式。
每一个容器的数据机构不同，所以取出动作细节也不同，但是有共性的内容。
通过iterator方法，实际获得的是Iterator子类对象，而Iterator的子类是定义在不同集合容器中的内部类，这样内部类可以直接读取集合中的元素。
*/
<span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">import java.util.*;
class CollectionDemo
{
public static void main(String args)
{
}
public static void base_method()
{
//创建一个集合容器，使用Collection接口的子类，ArrayList
ArrayList al=new ArrayList();
//1，添加元素
a1.add("java01")//add(Object obj);
a1.add("java02")
a1.add("java03")
//2.获取个数，集合长度
sop("size:"+al.size());
//打印集合
sop(al);//java01,java02
//3.删除元素。
al.remove("java02");
al.clear();//清空集合
//4.判断元素
sop("java03是否存在："+al.contains("java003"));
sop("集合是否为空："+al.isEmpty());
}
public static void method_2()
{
ArrayList al1=new ArrayList();
a11.add("java01");
a11.add("java02");
a11.add("java03");
a11.add("java04");
ArrayList al2=new ArrayList();
a12.add("java03");
a12.add("java04");
a12.add("java05");
a12.add("java06");
al1.retainAll(al2);//取交集，al1只会保留与al2相同的元素。
al1.removeall(al2);//将al1中删除与al2相同的部分。
}
public static void method_get()//取出元素，迭代器
{
ArrayList al=new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
a1.add("java04");
/*Iterator it=al.iterator();//iterator方法返回一个Iterator子类的型对象，Iterator是一个接口。
while(it.hasNext())//hasNext：当有元素返回真
{
sop(it.next());
}*/
for(Iterator it=al.iterator();it.hasNext();)//it作为局部变量，循环结束后，即消失，通常替代以上while循环使用
{
sop(it.next());
}
}
public static void sop(Object obj)
System.out.println(obj);
}
</span>
/*Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：线程不同步，查询速度很快，但是增删慢
|--LinkList:底层使用的是链表结构。特点：增删速度很快，查询速度稍慢。
|--Vecttor:底层是数组数据结构。先前出现的，线程同步，增删，查询都慢，被ArrayList替代了。
|--Set：元素是无序的，元素不可以重复。
List：
特有方法，凡是可以操作角标的方法都是该体系特有的方法。
增：
add(index,element)
addAll(index,Collection);
删
remove（index）；
改
set(index,element);
查
get(index);
subList(from,to)
ListIterator();
List集合特有的迭代器，ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合的元素；
因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。。
只能对元素进行判断，取出，删除的操纵。
如果想要其他的操作，例如添加，修改等，就需要使用其他接口，ListIterator。
该接口只能通过List集合的listIterator方法获取。
*/
import java.util.*;
class ListDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method()
{
ArrayList a1=new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
//在指定位置添加元素
a1.add(1,"java09");
//删除指定位置的元素
a1.remove(2);
//修改元素
a1.set(2,"java007");
//通过角标获取元素。
a1.get(1);
//获取所有元素
for(int x=0;x<a1.size();x++)
{
System.out.println(a1.get(x));
}
while(it.hasNext())
{
sop("next:"+it.next());
}
//通过indexOf（）获取对象位置
sop("index="al.indexOf("java02"));
List sub=al.subList(1,3);
sop("sub="+sub);
}
public static void main(String[] args)
{
//使用迭代器，但Iterator的方法是有限的，缺少添加，修改方法如下：
ArrayList a1=new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
/* 在迭代过程中，准备添加或删除元素。
Iterator it=al.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(obj.equals("java02"))
al.add("java008");
sop(obj="+obj);//此处会报错，抛出并发修改异常，因为对于同一组元素，
//不能同时进行集合和迭代器的操作，会产生安全隐患。
//要使用迭代器的方法
it.remove();//将java02的引用从集合中删除了。
sop("obj="+obj);
}*/
//使用列表迭代器ListIterator
ListIterator li=al.listIterator();
sop("hasPrevious():"+li.hasPrevious());//是否有前驱,结果为false
while(li.hasNext())
{
Object obj=li.next();
if(obj.equals("java002"))
{
li.addd("java009");
li.set("java006");
}
}
sop("hasNext():"+li.hasNext());//遍历完后，结果为false
sop("hasPrevious():"+li.hasPrevious());//遍历完后，结果为true。
while(li.hasPrevious())
{
sop("pre:"+li.previous());
}
}
}
/*Vector演示*/
import java.util.*;
/*枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代时一样的。
因为枚举的名称以及方法的名称过长。
所以被迭代器取代了。
枚举郁郁而终了。*/
class VectorDemo
{
public static void main(String[] args)
{
Vector v=new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java4");
Enumeration en=v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
/*LinkedList:特有方法
addFirst();
addLast();
getFirst();
getLast();//获取元素但不删除元素
removeFirst();
removeLast();//获取元素，删除元素，如果集合没有元素，会出现NoSuchElementException
在JDK 1.6出现了替代方法；
offerFirst();
offerLast();
peekFist();
peekLast();//获取元素，但不删除元素，如果集合没有元素，会返回null
poolFirst();
poolLast();获取元素，但是元素被删除，如果集合没有元素，会返回null
*/
class LinkedListDemo
{
public static void main(StrExceptioning[] args)
{
LinkedList l=new LinkedList();
l.addFirst("java01");
l.addFirst("java02");
l.addLast("java03");
l.addLast("java4");
sop(l.getFirst());//
sop(l.getLast());
sop(l.removeFirst());//remove也可用于获取元素，但会删除。
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*使用LinkList模拟一个堆栈或者队列数据结构
堆栈：先进后出
队列：先进先出
*/
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link=new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeLast();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl=new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
System.out.println(dl.myGet());
}
}
/*去除ArrayList集合中的重复元素*/
import java.util.*;
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop(al);
al=singleElement(al);
sop(al);
}
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))
newAl.add(obj);
}
return newAl;
}
}
/*ArrayList练习2
将自定义对象作为元素存到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;
}
public boolean equals(Object obj)//重写Object类的equals方法，接受Person类对象，使其成为比较姓名和年龄的方法。
{
if(!(obj instanceof Person))
return false;
Person p=(Person)obj;
System.out.println(this.name+"..."p.name);
return this.name.equals(p.name)&& this.age==p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class ArrayListTest2
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add(new Person("lisi01",30));//al.add(Object obj);Object obj=new Person("lisi01",30);
al.add(new Person("lisi02",31));
al.add(new Person("lisi02",31));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",34));
al.add(new Person("lisi04",34));
sop("remove 03:"+al.remove(new Person("lisi03",33)));//删除lisi03，实际上也是调用equals方法，将对象进行比较。
al=singleElement(al);//去掉重复元素
Iterator it=al.iterator();
while(it.hasNext())//打印现有元素
{
//sop(it.next().getName());//错误，it.next()返回的是Object型对象，它没有getName方法。
//所以必须进行向下转型。
Person p=(Person)it.next();
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方法，符合我们的比较要求。
newAl.add(obj);
}
return newAl;
}
}
/*
|--Set:元素是无序（存入和取出顺序是不一定一致的），元素不可以重复。
|--HashSet：底层数据结构式哈希表。线程是非同步的。
HashSet是如何保证元素唯一性的呢?
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，不会判断equals是否为true。
如果元素的hashcode值不同，才会调用equals。
注意:对于判断元素是否存在，以及删除等操作，依赖的方法，是元素hashcode和equals方法。
|--TreeSet：可以对Set集合中的元素自动进行排序
底层数据结构式二叉树。（在存入数据时，实际是按照compareTo方法返回的值来判断刚进入的数据是大还是小，
然后在底层自动构建二叉排序树，当取出时，对二叉排序树进行中序遍历，自然得到从小到大元素顺序。）
Set集合的功能和Collection是一致的。
*/
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add("java01");
hs.add("java01");
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
hs.remove(new Person("a3",13));//删除元素
Iterator it=hs.iterator();
while(it.haNext())
{
sop(it.next());//结果可能是无序的！保证是无序的！
}
}
}
/*HashSet存储自定义对象
往hashSet集合中存入自定义对象。
姓名和年龄相同为同一个人，重复元素。
!!!当存入新数据时，先比较他与容器内元素的哈希值是否相同，若不同则存入，若相同，再调用equals方法
与容器内元素比较，若不同，则存入，若相同，则舍去，因为HashSet不允许有重复元素。（我们可以重写
hashCode（）方法，和equals方法，实现自己的控制。）!!!
*/
import java.util.*;
class HashSetTest
{
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a2",13));
hs.add(new Person("a2",12));
Iterator it=hs.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();//it.next()返回的是Object型对象，必须进行强转。
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public int hashCode()//构造自己的哈希算法，是集合底层内调用的，equals也是
{
System.out.println(this.name+"...hashCode");
return name.hashCode()+age*39;
}
public boolean equals(Object obj)//重写Object类的equals方法，接受Person类对象，使其成为比较姓名和年龄的方法。
{
if(!(obj instanceof Person))
return false;
Person p=(Person)obj;
System.out.println(this.name+"...equals"p.name);
return this.name.equals(p.name)&& this.age==p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
/*TreeSet：可以对Set集合中的元素自动进行排序，
方式一：
1.！！！一定要实现comparable接口，复写compareTo(Object obj)方法，告知集合你想要的排序方式。
2.底层数据结构式二叉树。（在存入数据时，实际是按照compareTo方法返回的值来判断刚进入的数据是大还是小，
然后在底层自动构建二叉排序树，当取出时，对二叉排序树进行中序遍历，自然得到从小到大元素顺序。）
方式二：
当元素不具备比较性时，或者具备的比较性不是需要的。
这时需要让集合自身具备比较性。
在集合初始化时，就有了比较方式，考虑集合的构造方法。
方法；定义一个类，实现Comparator接口，覆盖compare方法。
注意：当两种排序都存在时，以比较器为主。
记住：排序时，当主要条件相同时，一定要判断一下次要条件。
需求：往TreeSet集合中存储自定义对象学生。按照学生的年龄进行排序。
*/
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add(new Strudent("lisi02",22));
ts.add(new Strudent("lisi007",20));
ts.add(new Strudent("lisi09",19));
ts.add(new Strudent("lisi08",19));
Iterator in=ts.iterator();
while(it.hasNext())
{
Student stu=(Student)it.next();
System.out.println(stu.nam+"..."+stu.age);
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)//实现该接口，强行使实现他的类的对象具有比较性。
{
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);//字符String类中本也具有比较方法compareTo,按照字典顺序比较
}
return -1;
}
}
/*TreeSet：方式二
当元素自身不具备比较性，或具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
*/
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)//实现该接口，强行使实现他的类的对象具有比较性。
{
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);//字符String类中本也具有比较方法compareTo,按照字典顺序比较
}
return -1;
}
}
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet(new MyCompare());//给TreeSet传递一个实现comparator的比较器的对象。
ts.add(new Strudent("lisi02",22));
ts.add(new Strudent("lisi007",20));
ts.add(new Strudent("lisi09",19));
ts.add(new Strudent("lisi06",18));
Iterator in=ts.iterator();
while(it.hasNext())
{
Student stu=(Student)it.next();
System.out.println(stu.nam+"..."+stu.age);
}
}
}
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Student s1=(Student)o1;
Sturdent s2=(Student)o2;
int num= s1.getName().compareTo(s2.getName());//这个compare方法，是字符串中的比较方法。
if(num==0)//当比较的姓名相同时，比较年龄。
{
if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()<s2.getAge())
return -1;
//或者直接进行年龄比较：new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
/*练习：按照字符串长度排序
字符串本身具备比较性，但是它的比较方式不是所需要的。
这时只能用比较器。*/
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet(new StringLengthComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("z");
ts.add("hahaha");
Iterator it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StringLengthComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1=(String)o1;
String s2=(String)o2;
/*
if(s1.length()>s2.length())
return 1;
if(s1.length()==s2.length())
return 0;
return -1;
*/
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}