集合框架
集合类
- 概述：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
- 与数组的区别：
- 数组：可存储基本数据类型，可存储对象，但长度是固定的，只能存同一类型的对象；
- 集合：只用于存储对象，长度是可变的，可以存储不同类型的对象；
- 数据结构：因为每个容器对数据的存储方式不同，这种存储方式称之为数据结构；
- 集合体系：
Collection接口
Collection的两个子接口：
- List：可存放重复元素，元素存取是有序的。
- ArrayList：底层数据结构是数组，查询快，增删慢，线程不同步；
- LinkedList：链表数据结构，增删快，查询慢；
- Vector：1.2版本功能，效率低，被ArrayList替代
- Set：不可以存放重复元素，元素存取是无序的。
- HashSet：底层数据结构是哈希表，线程不同步；
- TreeSet：底层是二叉树数据结构，可以对Set集合中的元素进行排序，线程不同步；
Collection中的共性方法：
| 返回值类型 | 方法 | 功能描述 |
|---|---|---|
| boolean | add(E e) | 添加元素 |
| boolean | addAll(Collection< ? extends E>c) | 添加指定集合中的所有元素 |
| void | clear() | 移除集合中的所有元素 |
| boolean | contains(Object o) | 集合中是否包含指定元素 |
| boolean | containsAll(Collection< ?> c) | 是否包含指定集合所有元素 |
| boolean | equals(Object o) | 比较集合与指定对象是否相等 |
| int | hashCode() | 返回此集合的哈希码值 |
| boolean | isEmpty() | 判断集合是否为空 |
| Iterator < E> | iterator() | 返回此集合的元素上进行迭代的迭代器； |
| boolean | remove(Object o) | 移除集中指定元素（若存在） |
| boolean | removeAll(Collection< ?> c) | 移除集合中包含在指定集合中的所有元素； |
| boolean | retainAll(Collection< ?> c) | 仅保留此集合中那些包含在指定集合的元素（取交集） |
| int | size() | 返回此集合中所有元素的个数； |
Iterator迭代器
- 迭代器是取出集合中元素的一种方式，因为Collection中有iterator方法，所以每个子类集合对象都具备迭代器；
- 获取迭代器的方式：
Collection对象可以通过调用自身的iterator方法，返回一个迭代器，例：
Collection< Object o> al=new ArrayList< Object o>();
Iterator it=al.iterator(); 迭代器的常用方法；
返回值类型 方法 功能描述 boolean hasNext() 如果仍有元素可以迭代返回true； E next() 返回迭代器的下一个元素； void remove() 从迭代器指向的集合中移除迭代器返回的最后一个元素； 迭代器的使用：
方式一：
for(Iterator iter = iterator();iter.hasNext();) { System.out.println(iter.next()); }方式二：
Iterator iter = l.iterator(); while(iter.hasNext()) { System.out.println(iter.next()); }
- 迭代注意事项：
- 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
- 迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
- 迭代器的next方法返回值类型是Object，所以要记得类型转换。
List集合中的常用类
List集合中的共性(特有)方法
| 返回值类型 | 方法 | 功能描述 |
|---|---|---|
| void | add(int index,E element) | 在列表的指定位置插入元素 |
| boolean | addAll(int index,Collection< ? extends E> c) | 将指定集合中所有元素都插入到列表中的指定位置 |
| E | get(int index) | 返回列表中指定位置的元素 |
| int | lastIndexOf(Object o) | 返回集合中最后出现的指定元素的索引，不存在返回-1； |
| ListIterator< E> | listIterator() | 返回此列表元素的列表迭代器 |
| ListIterator< E> | listIterator(int index) | 返回此列表元素的列表迭代器,从列表的指定位置开始 |
| E | remove(int index) | 移除列表中指定位置的元素 |
| E | set(int index,E element) | 用指定元素替换列表中指定位置的元素 |
| List< E> | subList(int formIndex,int toIndex) | 返回列表中指定的fromIndex（包括）和toIndex（不包括）之间的部分试图 |
注：集合在迭代时循环中next调用一次，hasNext就要判断一次，否则将会出现异常（奇数时可能出现访问不到的情况）；
ListIterator列表迭代器
- 概述：ListIterator列表迭代器是List集合特有的迭代器，该迭代器是Itreator迭代器的子接口；
- 区别：
- Iterator迭代器在迭代时不能通过集合对象的方法操作集合中的元素；
- ListIterator可以使用该迭代器下的方法对集合中的元素进行操作，如：添加、修改等；
- 该迭代器的获取方式与Iterator相同：
List< Object o> al=new ArrayList< Object o>();
ListIterator it=al.iterator(); - ListIterator常用方法
| 返回值类型 | 方法 | 功能描述 |
|---|---|---|
| void | add(E e) | 将指定元素插入列表 |
| boolean | hasNext() | 以正向遍历时，如果列表迭代器有多个元素，返回true |
| boolean | hasPrevious() | 如果以逆向遍历列表，列表迭代器有多个元素，返回true |
| E | next() | 返回列表中的下一个元素 |
| int | nextIndex() | 返回对next的后续调用所返回元素的索引 |
| E | previous() | 返回列表中的前一个元素 |
| int | previousIndex() | 返回对previous的后续调用所返回元素的索引 |
| void | remove() | 从列表中移除由next或previous返回的最后一个元素 |
| void | set(E e) | 用指定元素替换next或previous返回的最后一个元素 |
ArrayList
- 概述：底层数据结构使用的是数组，查询速度快，增删慢；线程不安全
- 创建一个ArrayList集合对象：
ArrayList al=new ArrayList();
al.add(“java01”);//向集合中添加元素；
Iterator it=al.iterator();//返回一个迭代器； - ArrayList集合是Collection集合框架下的子类，即可使用其自身的特有方法也可使用父类接口中的共性方法；
- ArrayList集合可使用特殊迭代器ListIterator，可在迭代的过程中对集合元素进行操作；
import java.util.*;
class ListDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void method(){
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合是："+al);
//在指定位置添加元素。
al.add(1,"java09");
//通过角标获取元素。
sop("get(1):"+al.get(1));
sop(al);
//获取所有元素。
for(int x=0; x<al.size(); x++){
System.out.println("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
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) {
//演示列表迭代器。
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop(al);
ListIterator li = al.listIterator();
//sop("hasPrevious():"+li.hasPrevious());
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
}
while(li.hasPrevious()){
sop("pre::"+li.previous());
}
//sop("hasNext():"+li.hasNext());
//sop("hasPrevious():"+li.hasPrevious());
sop(al);
}
}
Vector
- 概述：底层是数组数据结构，线程同步，被ArrayList替代了。因为效率低（JDK1.2版本）。
- 枚举(Enumeration)是Vector特有的取出方式，类似于Collection的迭代器，其实和迭代器是一样的，被Iterator取代；
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
LinkedList
- 概述：底层是链表数据结构，增删快，查询慢；
LinkedList类中的特有方法：
addFirst(E e);//将指定元素插入到列表开头；
addLast(E e);//将指定元素添加到列表结尾；
getFirst();//仅获取
getLast();//
removeFirst();//获取并删除
removeLast();
示例代码：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.removeFirst(); } 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()); } } }LinkedList类中的remove()方法；
remove()；移除首位；
remove(int index);移除指定位置元素
remove(Object obj);//移除指定元素- 特殊：
peekFirst();等效于getFirst()；//区别：前者JDK1.6出现的方法，集合为空会返回null，后者集合为空会提示异常；
peekLast();等效于getLast();//同上；
pollFirst();等同于removeFirst();//两者区别同上；
pollLast();等同于removeLast();//同上
附：如何选择使用ArrayList和LinkedList
当有增删较多的时候用LinkedList，当查询使用较多时用ArrayList，一般情况下使用ArrayList；
注：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)
{
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 Demo());
al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
//al.add(new Person("lisi02",32));
al.add(new Person("lisi02",32));
al.add(new Person("lisi04",35));
al.add(new Person("lisi03",33));
//al.add(new Person("lisi04",35));
//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();
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))
newAl.add(obj);
}
return newAl;
}
}
1023
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
