08.集合框架(一)【集合概述】【接口Collection,Iterator,List,ListIterator】【类LinkedList,ArrayList】

时间:2022-01-16 17:56:32


一.集合概述

1.      集合类的由来

对象用于封装特有数据,对象多了需要存储,如果对象个数不确定,就使用集合容

        器进行存储。

2.      集合的特点(集合与数组的区别)

1) 集合是用于存储对象的容器,存储的对象可以是不同的引用数据类型

数组既可以存储基本数据类型,也可以存储引用数据类型。

2) 集合的长度可变

数组的长度是固定的

3) 集合不能存储基本数据类型值,只能存储引用数据类型

数组只能存储同一个数据类型的值

3.      集合框架

集合容器因为内部的数据结构(对数据的存储方式)不同,于是就产生了多重具体容器。不断的向上抽取,就形成了集合框架。

                08.集合框架(一)【集合概述】【接口Collection,Iterator,List,ListIterator】【类LinkedList,ArrayList】  

 

二.Collection接口

1.      Collection

Collection接口在整个集合框架中处于顶层位置。它是底层不断向上抽取而得的。

        Collection接口还有很多子接口,常用的子接口有两个:

                  List有序的Collection(也称为序列)。可以存储重复元素,每个元素都有索引

                           所谓有序,并不是从大到小或者从小到大排列,而是元素存储顺序和取出顺序

                           一致。

                  Set无序。不可以存储重复元素。因为必须要保证元素的唯一性。

2.      Collection接口的常用方法

1) 添加

boolean add(E e):往集合中添加一个元素。

boolean add(Collection<? extends E> c):将指定集合的所有元素添加到此集合中。

2) 删除

void clear():删除此集合中所有的元素。

boolean remove(Objeact o):从集合中删除某一个元素。

boolean removeAll(Collection<?> c):删除此集合中那些包含在指定集合中的元素。

3) 判断

boolean contains(Object o):此集合中是否包含指定元素。

boolean containsAll(Collection<?> c):此集合中是否包含指定集合的所有元素。

boolean isEmpty():判断集合是否为空。

4) 获取

int size():获取此集合中的元素个数。

                  例子:

                

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {

/**
* @param args
*/
public static void main(String[] args) {

Collection coll = new ArrayList();


show(coll);

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("abc2");
c2.add("abc5");
c2.add("abc6");

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("c1:"+c1);






}


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);


}

}

三.Iterator接口

1.迭代器

        此接口就是一个迭代器,用于对集合进行迭代。简单说,就是集合取出元素的方法。

2.迭代器的由来

集合通常将元素的取出方式定义在集合内部,这样方便访问集合的元素,所以取出方式通常被定义内部类。不同的具体的集合容器,其数据结构不同,导致取出元素的方式也不一样。将不同集合中取出方式的共性内容向上抽取,得到Iterator

3.      迭代器的方法

                  booleanhasNext():如果仍有元素可以迭代,则返回true

                  Enext():返回下一个迭代的元素。

                  voidremove():从迭代器指向的集合中移除迭代器返回的最后一个元素。

4.      循环迭代时用while循环还是for循环?

while循环:迭代完之后,迭代器没有被释放,会占内存。

          使用范围:如果你还想用这个迭代器,那么就用while循环。

for循环:for循环结束后,迭代器也跟着被释放。

          使用范围:开发时用for循环,节省内存。      

5.      使用迭代器的注意事项

1) 迭代器在Collection接口中是通用的,它替代了枚举(Enumeration)。

2) 迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException

3) Next()方法返回值类型是Object,使用时要记得类型转换。

                        例子:

                      

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中的iteractor()方法,调用集合中的迭代器方法,是为了获取集合中的迭代器对象。
//Iterator it = coll.iterator();

//while(it.hasNext())//使用hasNext方法,避免异常。
//System.out.println(it.next());

/*
* 但是,while循环,it迭代器没有消失。而且里面为空。占内存,
* 如果你还想用这个迭代器,那么就 用while循环。
* 否则,就用for循环。for循环结束后,迭代器也跟着消失。
* 开发时用for循环。
*/

for (Iterator it = coll.iterator();it.hasNext(); ) {

System.out.println(it.next());

}

}

}

 

四.List接口

1.      List子体系

List有序的Collection(也称为序列)。可以存储重复元素,每个元素都有索引

凡是可以操作角标的,就用list

list集合是可以完成对元素的增删改查。

2.      实现List接口的常用子类

List:

|--Vector:内部是数组数据结构。是同步的。增删,查询都很慢!

|--ArrayList:内部是数组数据结构,是不同步的。效率高,替代了Vector。多线

                程的时候,把方法都放到同一个锁就行了查询的速度快。

|--LinkedList:内部是链表数据结构,是不同步的。增删元素的速度很快。

3.      List的常见特有方法:共性的特点就是可以操作角标。

1)添加

   voidadd(index,element);添加元素到指定位置。

   voidadd(index,collection);添加指定集合中的元素到指定位置。

2)删除

      Objectremove(index);删除指定位置的元素。

3)修改

   Objectset(index,element);修改指定位置的元素。

4)获取

   Objectget(index);根据角标获取元素。

   int indexOf(object);根据元素获取第一次出现的角标。没有该元素,返回-1.

   int lastIndexOf(object);获取元素最后出现的位置。

   ListsubList(from,to);获取列表中指定的from(包括)to(不包括)之间

                            的元素。

                  5listIterator();List特有的迭代器。封装了多个方法,避免了迭代时操作动作的局

                                                       限。

 

                  TipList集合判断元素是否相同,移除等操作,底层调用的是equals方法。

         例子:

         

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);

list.add("abc1");
list.add("abc2");
list.add("abc3");

ListIterator it = list.listIterator();
/*
* 获取列表迭代器对象
* 迭代器本身只有获取,判断,删除三个方法。但是列表迭代器接口里包含了列表的增删查改等操作。
* 所以它可以实现迭代过程中完成对元素的增删查改。
*
* 注意:只有list集合具有该迭代功能。
*/

while(it.hasNext()){

Object obj = it.next();

if(obj.equals("abc2")){
it.set("abc99");
}
}
System.out.println(list);

//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);


/*Iterator it = list.iterator();
while(it.hasNext()){

Object obj = it.next();//java.util.ConcurrentModificationException
//发生了并发修改,抛出此异常。
//在迭代器过程中,不要使用集合操作元素,容易出现异常。
//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。

if(obj.equals("abc2")){
list.add("abc9");
}
else
System.out.println("next:"+obj);
}
System.out.println(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());

for(int i = 0;i<list.size();i++){

System.out.println("get:"+list.get(i));

}

}
}

 

五.ListIterator接口

1.      ListIterator的由来

ListIteratorList集合特有的迭代器,是Iterator的子接口。

Iterator在迭代Collection集合时,只能判断,取出,删除元素,如果要添加元素等操作,很容易造成并发修改,并抛出ConcurrentModificationException异常。为了能

                  在迭代List集合时实现更多的操作,于是就抽取形成了ListIterator接口。

2.      ListIterator接口特有的方法

add(obj)添加

set(obj)修改为指定元素

hasPrevious()判断之前有没有元素

previous()获取前一个元素

六.枚举接口(Enumeration

                Enumeration接口和Iterator接口的功能是一样的,只不过Iterator接口方法名比较

        短,实现时优先考虑用Iterator接口。

         例子:枚举和Iterator接口

        

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorDemo {
/*
* Enumeration接口和Iteractor接口的功能是重复的。只不过Iteractor接口
* 方法名比较短,实现时应优先考虑使用Iteractor接口。
*/
public static void main(String[] args) {

Vector v = new Vector();

v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");

//Enumeration接口
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println("next element:"+en.nextElement());
}

//Iterator接口
Iterator it = v.iterator();
while(it.hasNext()){
System.out.println("next:"+it.next());
}
}
}


 

 

七.LinkedList

LinkedList实现了List接口,其数据结构为链表。

        特点:增删速度快,查询稍慢。

        1.方法

                  1)添加

                        addFirst();

          addLast();

       2)获取

           getFirst();//获取但不移除,如果链表为空,抛出NoSuchElementException

          getLast();

       3)删除

           removeFirst();//获取并移除,如果链表为空,抛出NoSuchException

          removeLast();

2.1.6之后的新方法

       1)添加

                          offerFirst();

          offerLast();       

2)获取

           peekFirst();//获取但不移除,如果链表为空,返回null

          peekLast();

       3)删除

           pollFirst();//获取并移除,如果链表为空,返回null

           pollLast();

        例子:

       

import java.util.LinkedList;

/*
* 请使用LinkedList来模拟一个堆栈或者队列数据结构。
*
* 堆栈:先进后出。First In Last Out FILO
*
* 队列:先进先出。First In First Out FIFO
* 例子:公交车,上车往后走,先上车,先到后门下车。
* 我们应该描述这样一个容器,给使用者提供一个容器对象完成这两种结构中的一种。
*/

public class LinkedTest {

public static void main(String[] args) {

DuiLie dl = new DuiLie();

dl.myAdd("add1");
dl.myAdd("add2");
dl.myAdd("add3");
dl.myAdd("add4");
dl.myAdd("add5");

while(!dl.isNull()){
System.out.println(dl.myGet());
}
System.out.println(dl.isNull());
}
}


DuiLie类

import java.util.LinkedList;

/*
* 队列(或者堆栈)结构。
*/
public class DuiLie{

private LinkedList link;
DuiLie(){
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();
}
}


 

 

八.ArrayList

ArrayList:内部是数组数据结构,是不同步的。效率高,替代了Vector。多线程的时候,把方法都放到同一个锁就行了,查询的速度快。

如果添加或者删除元素,列表长度会改变,其他元素也跟着动。

   方法和列表的方法基本相同。

   举一个例子:

   

import java.util.ArrayList;
import java.util.Iterator;

import cn.itcast.p.bean.Person;

public class ArrayListTest {

public static void main(String[] args) {

ArrayList al = new ArrayList();
al.add(new Person("lisi1",21));
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()){

//System.out.println(((Person) it.next()).getName()+"..."+((Person) it.next()).getAge());
/*
* 不要在循环语句里调用两次next(),它会自动往下走,操作的将不是同一个对象,结果出错。
* 既然要对一个对象进行多步操作,可以给对象起个名字,方便操作。
*
* 注意:
* 存自定义对象的时候,一定要考虑到取出动作:强转。
* 不强转的话,自动变成字符串输出。有的字符串没有定义字符串方法,会调用父类的toString方法,
* 打印的是类型+哈希值。这样没有意义。
*/

//向下转型,才能使用Person子类的特有方法。
Person p = (Person) it.next();
System.out.println(p.getName()+"..."+p.getAge());

}

//al.add(5);//al.add(new Integer(5));自动装箱。
//装箱:基本数据类型赋值给引用数据类型时会自动装箱,其实就是多态。
//拆箱:基本数据类型和引用数据类型同时参与运算时。
}
}