Java笔记--集合
1.用来存储对象的一种常见方式
2.集合的特点
（1）集合只用来存储对象
（2）集合的长度是可变的
（3）集合可以存储不同类型的对象
3.为什么会出现这么多的容器呢
因为每一个容器对数据的存储方式都不同，这个存储方式就称为数据结构
4.集合中存储的都是对象的引用（地址）
5.迭代器（通常用来遍历集合）
其实就是集合取出元素的方式
取出方式被定义成了内部类，定义在集合的内部，这样取出方式就可以直接访问集合中的元素，而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容----判断和取出，那么就可以将共性抽取。这些内部类都符合一个规则，该规则就是Iterator。
如何获取集合的取出对象呢？
通过一个对外提供的方法iterator();
实例
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java 01");
al.add("java 02");
al.add("java 03");
al.add("java 04");
for(Iterator it = al.iterator();it.hasNext();)
{
sop(it.next());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
6.集合框架
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系中有索引
特有方法：凡是可以操作角标的方法都是该体系的特有方法
|--ArrayList：底层的数据结构是数组数据结构，特点是查询速度很快，但是
增删稍慢，线程不同步
|--LinkedList：底层使用的是链表数据结构，特点：增删速度很快，查询稍慢
|--Vector：底层是数组数据结构，线程同步。被ArrayList代替了
|--Set：元素是无序的（存入和取出的顺序不一定一致），元素不可以重复
Set集合的功能和Collection是一致的，
|--HashSet：底层数据结构是哈希表，线程不同步
HashSet是如何保证元素的唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成的
如果元素的HashCode值相同，才会判断equals是否为true
如果元素的HashCode值不同，则不会判断equals。
|--TreeSet：可以对Set集合中的元素进行排序
底层结构是二叉树
保证元素唯一性的依据：compareTo方法return 0
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comoparable接口，覆盖compareTo方法
TreeSet排序的第二种方式：当元素自身不具备比较性，或者具备的
比较性不是所需要的。这时需要让容器自身具备比较性。定义了比
较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在的时候，以比较器为主
定义一个类，实现Comparator接口，覆盖compare方法，将该类对
象作为参数传递给TreeSet集合的构造器
注意：排序时，当主要条件相同时，一定要判断下次要条件
7.ListIterator是Iterator的子接口，是List集合特有的迭代器，在迭代的时候，不可以通过对象的方法操作集合中的元素，因为会发生ConcurrentModificationException并发修改异常，所以在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断、取出、删除的操作，如果想要进行其它的操作，如添加、修改等就需要使用其子接口ListIterator。该接口只能通过List集合的listIterator方法获取。
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java 01");
al.add("java 02");
al.add("java 03");
al.add("java 04");
ListIterator li = al.listIterator()；
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java 02"))
{
li.set("java 10"); //替换元素
//li.add("java 10"); //添加一个新的对象引用
}
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
8.枚举是vector特有的取出方式
枚举和迭代器很像，其实枚举和迭代是一样的，因为枚举的名称以及方法都过长，所以被迭代器取代了，枚举就郁郁而终了。
class VectorDemo
{
public static void main(String[] args)
{
Vector ve = new Vector();
ve.add("java 01");
ve.add("java 02");
ve.add("java 03");
ve.add("java 04");
Enumeration en = ve.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
9.LinkedList的特有方法
addFirst（）；
addLast（）；
//获取元素，但不删除元素，如果集合中没有元素，
//会出现NoSuchElementException异常
getFirst();
getLast();
//获取元素，但元素被删除。，如果集合中没有元素，
//会出现NoSuchElementException异常
removeFirst（）；
removeLast（）；
在JDK1.6出现了替代方法
offerFirst();
offerLast();
//获取元素，但不删除元素，如果集合中没有元素，
//会返回null
peekFirst();
peekLast();
//获取元素，但元素被删除。，如果集合中没有元素，
//会返回null
pollFirst();
pollLast();
10.用LinkedList模拟一个队列或堆栈的数据结构
import java.util.*;
class MyQueue
{
private LinkedList link;
MyQueue()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
//return link.removeLast(); //模拟一个队列
return link.removeFirst(); //模拟一个堆栈
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListDemo
{
public static void main(String[] args)
{
MyQueue myQueue = new MyQueue();
myQueue.myAdd("java 01");
myQueue.myAdd("java 02");
myQueue.myAdd("java 03");
myQueue.myAdd("java 04");
while(!myQueue.isNull())
{
System.out.println(myQueue.myGet());
}
}
}
11.去除ArrayList集合中的相同元素
import java.util.*;
class ArrayListDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java 01");
al.add("java 02");
al.add("java 01");
al.add("java 02");
al.add("java 03");
sop("原来" + al);
al = singleElement(al);
sop(al);
}
public static ArrayList singleElement(ArrayList al)
{
ArrayList newal = new ArrayList(); //创建一个新的ArrayList集合
Iterator it = al.iterator(); //使用迭代器遍历原集合
while(it.hasNext())
{
//注意在迭代循环时，next()调用一次，就需要用hasNext()判断一次
Object obj = it.next(); //使用迭代器遍历集合
if(!newal.contains(obj))
newal.add(obj);
}
return newal;
}
}
12.将自定义的对象存到ArrayList集合中，并去除相同元素
存人对象，同一姓名，同于元素的人视为同一个人
*/
import java.util.*;
class Person
{
private String name;
private int age;
//重写父类的equals方法
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj; //向下转型
return (p.name.equals(this.name) && p.age == this.age);
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class ArrayListDemo
{
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",35));
al.add(new Person("lisi02",32));
al.add(new Person("lisi02",32));
al.add(new Person("lisi04",39));
al.add(new Person("lisi04",39));
al = singleElement(al);
Iterator it = al.iterator();
while(it.hasNext())
{
//下面两个语句等同于 Person p = (Person)it.next();
Object obj = it.next();
Person p = (Person)obj; //向下转型
sop(p.getName() + "::" + p.getAge());
}
}
public static ArrayList singleElement(ArrayList al)
{
ArrayList newal = new ArrayList(); //创建一个新的ArrayList集合
Iterator it = al.iterator();
while(it.hasNext())
{
//注意在迭代循环时，next()调用一次，就需要用hasNext()判断一次
Object obj = it.next(); //使用迭代器遍历集合
//List集合判断元素是否相同，调用的是equals()方法
//下面调用的contains()方法底层调用的也是equals()方法
//所以需要在Person类中，重写根父类的equals()方法
if(!newal.contains(obj))
newal.add(obj);
}
return newal;
}
}
13. HashSet是如何保证元素的唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成的
如果元素的HashCode值相同，才会判断equals是否为true
如果元素的HashCode值不同，则不会判断equals。
对于判断元素是否存在，以及删除等操作，依赖的方法是
元素的hashCode和equals方法
import java.util.*;
class Person
{
private String name;
private int age;
public int hashCode() //重写父类的哈希函数
{
return name.hashCode()+age * 37;
}
public boolean equals(Object obj) //重写父类的equals方法
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return (p.name.equals(this.name) && p.age == this.age);
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class HashCodeDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hc = new HashSet();
hc.add(new Person("lisi01",11));
hc.add(new Person("lisi02",12));
hc.add(new Person("lisi03",13));
hc.add(new Person("lisi04",14));
hc.add(new Person("lisi02",12));
//同样依赖hashCode和equals方法
sop(hc.remove(new Person("lisi01",11)));
Iterator it = hc.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName() + "::" + p.getAge());
}
}
}
14.TreeSet：可以对Set集合中的元素进行排序
底层结构是二叉树
保证元素唯一性的依据：compareTo方法return 0
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comoparable接口，覆盖compareTo方法
这种方式也称为元素的自然顺序，也称为默认顺序
注意：排序时，当主要条件相同时，一定要判断下次要条件
/*
需求：根据学生的年纪进行排序，当学生的年纪相同时，根据姓名排序
*/
import java.util.*;
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
public int compareTo(Object obj) //该类强制让学生具备比较性
{
if(!(obj instanceof Student))
throw new RuntimeException("比较的对象不是Student对象");
Student stu = (Student)obj;
if(this.age > stu.age)
return 1;
if(stu.age == this.age)
//排序时，当主要条件相同时，一定要判断下次要条件
//当年纪相同时，再根据姓名排序
return this.name.compareTo(stu.name);
return -1;
}
}
class TreeSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi01",20));
ts.add(new Student("lisi02",21));
ts.add(new Student("lisi02",20));
ts.add(new Student("lisi03",22));
ts.add(new Student("lisi04",23));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName() + "::" + stu.getAge());
}
}
}
TreeSet的第二种排序方式
当元素自身不具备比较性时，或者具备的比较性不是所需要 的，这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在的时候，以比较器为主
定义一个类，实现Comparator接口，覆盖compare方法
/*
需求：根据学生的年纪进行排序，当学生的年纪相同时，根据姓名排序
*/
import java.util.*;
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int getAge()
{
return age;
}
public String getName()
{
return name;
}
public int compareTo(Object obj) //该类强制让学生具备比较性
{
if(!(obj instanceof Student))
throw new RuntimeException("比较的对象不是Student对象");
Student stu = (Student)obj;
if(this.age > stu.age)
return 1;
if(stu.age == this.age)
return this.name.compareTo(stu.name);
return -1;
}
}
class TreeSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi01",20));
ts.add(new Student("lisi02",21));
ts.add(new Student("lisi09",20));
ts.add(new Student("lisi007",22));
ts.add(new Student("lisi04",23));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName() + "::" + stu.getAge());
}
}
}
class MyCompare implements Comparator
{
//在比较器中按姓名进行排序
public int compare(Object obj1,Object obj2)
{
Student stu1 = (Student)obj1;
Student stu2 = (Student)obj2;
int num = stu1.getName().compareTo(stu2.getName());
if(num == 0)
{
return new Integer(stu1.getAge()).compareTo(new
Integer(stu2.getAge()));
}
return num;
}
}
练习
/*
练习：按照字符串长度排序
字符串本身具备比较性，但是它的比较方式不是所需要的
这是就使用比较器进行比较
*/
import java.util.*;
class TreeSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new strLenCompare());
ts.add("abc");
ts.add("d");
ts.add("esdsdcas");
ts.add("us");
ts.add("sde");
Iterator it = ts.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
class strLenCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
//注意compareTo方法返回的正数不一定是，返回的负数不一定是-1
int num = new Integer(s1.length()).compareTo(s2.length());
if(num == 0)
{
//当字符串的长度相同时，按字符串的自然顺序进行排序
return s1.compareTo(s2);
}
return num;
}
}