集合类 迭代器iterator List：ListIterator ArrayList Vector()elements LinkedList equals应用

时间：2022-04-23 19:25:41

集合类

 面向对象语言中，事物都是以对象的形式体现的，所以为了方便对象的操作，就要对对象进行存储，集合就是存储对象的最常见方法之一。

数组和集合类有何不同！

虽然数组和集合都是容器，都可以用于存储数据，但是

数组的长度是固定的，数组中可以存储基本数据类型。

集合长度是可变的，集合只能存放对象。


集合框架

因为java中有很多不同类型的集合，用于存储不同类型的对象。

当我们对着写集合进行共性抽取的时候，会产生一个体系，这个体系就是集合框架。


为什么会有这么多的容器？

因为每一个容器对数据的存储方式各有不同。

这个存储方式称之为：数据结构。

collection接口

|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。

   |--ArrayList:底层的数据结构使用的是数组结构

   |--LinkedList

底层使用的链表数据结构

   |--Vector:

|--Set：元素是无序的，元素不可以重复。该集合当中没有索引。

   |--HashSet

   |--TreeSet


Collection集合中的共性方法：

1，add方法的参数类型是Object，以便于接受任意类型的对象。

2，集合中存储的都是对象的引用，就是地址。

add remove  clear

contains isEmpty    size

import java.util.*;
class  Test
{
public static void main(String[] args) 
{
//创建一个集合容器，使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();

//1 添加元素
al.add("java01");//add(Object obj)
al.add("java02");
al.add("java03");
al.add("java04");

//打印集合
sop(al);//[java01, java02, java03, java04]
//2 获取个数，集合长度
sop("size="+al.size());//size=4

//3删除元素
al.remove("java02");
sop(al);//打印改编后的集合。 [java01, java03, java04]
//al.clear(); // 清空集合。

//4判断元素
sop("java03是否存在:"+al.contains("java03"));
//判断集合是否为空
sop("集合是否为空："+al.isEmpty());

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

retainAll 和 removeAll

a1.retainAll(a2);

取交集，a1中只会保留和a2中相同的元素

a1.removeAll(a2);

a1中只保留与a2不同的元素 

import java.util.*;
class  Test
{
public static void main(String[] args) 
{
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
a1.add("java04");

ArrayList a2 = new ArrayList();
a2.add("java01");
a2.add("java02");
a2.add("java05");
a2.add("java06");

a1.retainAll(a2); //取交集，a1中只会保留和a2中相同的元素
sop(a1);//[java01, java02]
sop(a2);//[java01, java02, java05, java06]

a1.removeAll(a2);//a1中只保留与a2不同的元素
sop(a1);//[java03, java04]
sop(a2);//[java01, java02, java05, java06]
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

迭代器   Iterator(接口)

举例子：电玩城的夹娃娃，夹娃娃机器有很多种，都是一个透明的箱子，里面放着不同的娃娃。就如同集合容器，不同的容器装着不同的内容。但每个夹娃娃的机器中，都有一个夹子，而且都是在透明箱子的内部。但是每种机器里的夹子也有不同，有2个抓的，有三个抓的，因为容器中的娃娃不同，也有所不同。但是，每个机器外面都有一个操纵杆，通过这个杆可以操控夹子，让架子前后移动，上下移动，看准后，按下操纵杆，去抓娃娃。迭代器就列斯这个操纵杆，每个集合容器中，都有自己的迭代器，根据容器内对象的不同，迭代器的实现也不同，但是都可以通过迭代器的接口去获取内容。

迭代器（iterator）其实就是集合的取出元素的方式。

就是把取出方式定义在集合的内部

这样取出方式就可以直接访问集合内容的元素

那么取出方式就被定义成了内部类

而每一个容器的数据结构不同，

所以取出的 动作细节也不一样。但是都是共性内容

判断  和  取出。那么可以将这些共性抽取。

那么这些内部类都符合一个规则。该规则是Iterator。

通过 iterator(); 提供外部访问方法。

hasNext（），判断集合中是否还有元素。有就返true，没有就返回false。

next（），取出集合中元素。

for循环结束，it1释放，节省内存
        for (Iterator it1 =a1.iterator();it1.hasNext() ;)
        {
                sop(it1.next());
        }

import java.util.*;
class  Test
{
public static void main(String[] args) 
{
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
a1.add("java04");

Iterator it = a1.iterator();  //获取迭代器，用于取去集合中的元素
while (it.hasNext())
{
sop(it.next());

}
//for循环结束，it1释放，节省内存
for (Iterator it1 = a1.iterator();it1.hasNext() ; )
{
sop(it1.next());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
 

 

List：
 

 

|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。
 

|--Set：元素是无序的，元素不可以重复。该集合当中没有索引。
 

 

list方法
 

凡是可以操作脚标的方法，都是该体系特有的方法。
 

增
 

add（index，element）;
 

addAll（index，collection）;
 

删
 

remove（index）;
 

改 
 

set(indxe,element);
 

查 
 

get(index);
 

subList(from,to);
 

listIterator();



 

import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");

sop(al);//[java01, java02, java03]
//在角标1处添加java09
al.add(1,"java09");
sop(al);//[java01, java09, java02, java03]
//删除2角标元素
al.remove(2);
sop(al);//[java01, java09, java03]
//修改2脚标元素为java10
al.set(2,"java10");
sop(al);//[java01, java09, java10]
//查询1角标元素
sop("get[1]="+al.get(1));
//获取所有元素
for (int x =0;x<al.size() ;x++ )
{
System.out.println("al["+x+"]="+al.get(x));
}
//获取所有元素
for (Iterator it = al.iterator();it.hasNext() ; )
{
sop("next:"+it.next());
}Iterator ite= al.iterator();
while (ite.hasNext())
{
sop("next="+ite.next());
}
//通过indexOf获取对象的位置
sop("index="+al.indexOf("java01"));

//获取指定位置的元素
List sub = al.subList(1,3);
sop("sub="+sub);
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}
 

 

ListIterator
 

List 集合特有的迭代器，ListIterator是Iterator的子接口。



在迭代式，不可以通过集合对象的方法操作集合中的元素。
 

因为会发生 java.util.ConcurrentModificationException异常
 

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。
 

只能对元素进行判断，取出，删除的操作。
 

如果想要其他的额操作如添加，修改等，就需要使用其子接口listIterator。
 

该接口只能通过List集合的ListIterator方法获取。
 

import java.util.*;
class ListDemo
{
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();

while (li.hasNext())
{
Object obj = li.next();
if (obj.equals("java02"))
{
li.set("java10"); //修改元素
li.add("java002"); //添加元素
}
}
sop(al);

//反向遍历
while (li.hasPrevious())
{
sop("hasPrevious:"+ li.previous());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}




|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。


|--ArrayList:底层的是数组结构


（默认长度是10，当超过，new+50%的新数组，将原数组搬过来，在把包超过的搬进来）  


特点：查询速度很快，但是增删稍慢，线程不同步。


|--LinkedList :底层使用的链表数据结构


特点：增删速度很快，查询稍慢。


|--Vector ：底层是数组数据结构


（默认长度是10，当超过，new+100%的新数组，将原数组搬过来，在把包超过的搬进来）  


特点：线程同步。增删都很慢，被ArrayList替代了。


Vector()  的 elements


Enumeration枚举（类似Iterator）


枚举就是Vertor特有的取出方式。


发现枚举和迭代很像，


其实枚举和迭代是一样的。


因为枚举的名称以及方法的名称过长。


所以被迭代器取代了。


枚举郁郁而终了


import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
Vector v = new Vector();

v.add("java01");
v.add("java02");
v.add("java03");

Enumeration en = v.elements();

while(en.hasMoreElements())
{
sop(en.nextElement());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}


LinkedList 
特有方法 
  




LinkedList
 
     
链表结构
 
    




addFirst( ); 
 
     
在头部添加，因为结构，所以往后推着加入元素
 
    




addLast( ); 
 
     
在尾部添加，因为结构，所以可以从尾部添加元素
 
    




getFirst( );
 
     
获取头部值，获取第一个元素。
 
    




getLast( ); 
 
     
获取尾部值，获取最后一个元素。
 
    




removeFirst( ); 
 
     
获取头部值，并移除头部值 
 
    




removeLast( );
 
     
获取尾部值，并移除尾部值
 
    



当集合中没有元素，为空时提示NoSuchElementException

在 JDK1.6出现了代替方法。addFirst( ); 在头部添加 offerFirts（）addLast( ); 在尾部添加 offerLast（）
getFirst( ); 获取头部值 peekFirst（）getLast( ); 获取尾部值 peekLast（）
removeFirst( ); 获取头部值，并移除头部值  pollFirst（）removeLast( ); 获取尾部值，并移除尾部值 pollLast（）
import java.util.*;
class test 
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();

link.add("java01");
link.add("java02");
link.add("java03");
link.add("java04");

addFirst("javafirst");// 在头部添加
addLast("javalast"); //在尾部添加

getFirst(); //获取头部值
getLast(); //获取尾部值

removeFirst();//获取头部值，并移除头部值
removeLast();//获取尾部值，并移除尾部值

//清空
while(!link.isEmpty())
{
sop(link.removeLast());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}


练习
/*
使用LinkedList模拟一个堆栈或者队列数据结构

堆栈：先进后出。如同杯子。
队列：先进先出。First in first 如同水管，

*/
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();//先进先出
//return link.removeFirst(); 先进后出
}

public boolean inNull()
{
return link.isEmpty();
}

}

class Test
{
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)
{
sop(dl.myGet());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}


/*
去除ArrayList中的重复元素。
*/
import java.util.*;
class Test
{
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;
}
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 void sop(Object obj)
{
System.out.println(obj);
}
}

超重点 equals应用
/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素
比如：存人对象，同姓名，同年龄，视为同一个人，为重复元素。
思路
1对人描述，将数据封装进人对象
2定义容器，将人存入
3取出

结论
List集合判断元素是否相同该，依据的是元素的equals方法。
*/
import java.util.*;
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;
return this.name.equals(p.name)&& this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class Test
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();

al.add(new Person("lisi01",30));
al.add(new Person("lisi02",35));
al.add(new Person("lisi03",32));
al.add(new Person("lisi02",35));
al.add(new Person("lisi03",32));
al.add(new Person("lisi04",31));

al=singleElement(al);

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

public static void sop(Object obj)
{
System.out.println(obj);
}
}




标签：
相关文章