【移动应用开发技术】Android中怎么实现迭代器模式

【移动应用开发技术】Android中怎么实现迭代器模式

这期内容当中在下将会给大家带来有关Android中怎么实现迭代器模式，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。一、介绍迭代器模式（IteratorPattern）又称为游标（Cursor）模式，是行为型设计模式之一。迭代器模式算是一个比较古老的设计模式，其源于对容器的访问，比如Java中的List、Map、数组等，我们知道对容器对象的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将遍历的方法封装到容器中，那么对于容器类来说就承担了过多的功能，容器类不仅要维护自身内部的数据元素而且还要对外提供遍历的接口方法，因为遍历状态的存储问题还不能对同一个容器同时进行多个遍历操作，如果我们不提供遍历方法而让使用者自己去实现，又会让容器的内部细节暴露无遗，正因于此，迭代模式应运而生，在客户访问类与容器体之间插入了一个第三者——迭代器，很好地解决了上面所述的弊端。二、定义提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。三、使用场景遍历一个容器对象。四、迭代器模式的UML类图UML类图：通用模式代码：迭代器接口：public

interface

Iterator<T>

{

/**

*

是否还有下一个元素

*

@return

true表示有，false表示没有

**/

boolean

hasNext();

/**

*

返回当前位置的元素并将位置移至下一位

**/

T

next();

}具体迭代器类：public

class

ConcreteIterator<T>

implements

Iterator<T>{

private

List<T>

list;

private

int

cursor

=

0;

public

ConcreteIterator(List<T>

list)

{

this.list

=

list;

}

@Override

public

boolean

hasNext()

{

return

cursor

!=

list.size();

}

@Override

public

T

next()

{

T

obj

=

null;

if

(this.hasNext())

{

obj

=

this.list.get(cursor++);

}

return

obj;

}

}容器接口：public

interface

Aggregation<T>

{

/**

*

添加一个元素

**/

void

add(T

obj);

/**

*

移除一个元素

**/

void

remove(T

obj);

/**

*

获取容器的迭代器

**/

Iterator<T>

iterator();

}具体容器类：public

class

ConcreteAggregation<T>

implements

Aggregation<T>{

private

List<T>

list

=

new

ArrayList<>();

@Override

public

void

add(T

obj)

{

list.add(obj);

}

@Override

public

void

remove(T

obj)

{

list.remove(obj);

}

@Override

public

Iterator<T>

iterator()

{

return

new

ConcreteIterator<>(list);

}

}客户类：public

class

Client

{

public

static

void

main(String

args[])

{

Aggregation<String>

a

=

new

ConcreteAggregation<>();

a.add("a");

a.add("b");

a.add("c");

Iterator<String>

iterator

=

a.iterator();

while

(iterator.hasNext())

{

System.out.print(iterator.next());

}

}

}角色介绍：Iterator：迭代器接口，迭代器接口负责定义、访问和遍历元素的接口。ConcreteIterator：具体迭代器类，具体迭代器类的目的主要是实现迭代器接口，并记录遍历的当前位置。Aggregate：容器接口，容器接口负责提供创建具体迭代器角色的接口。ConcreteAggregate：具体容器类，具体迭代器角色与该容器相关联。Client：客户类。五、简单实现小民和小辉分别在公司的两个事业部，某天老板安排任务让他们俩统计一下各自部门的员工数据，这很好办嘛，建一个类用数据结构把所有员工数据存进去即可，老板要看的时候给他用for循环实现，还是比较容易的，下面就先为员工创建一个实体类：员工实体类：public

class

Employee

{

private

String

name;//

姓名

private

int

age;//

年龄

private

String

sex;//

性别

private

String

position;//

职位

public

Employee(String

name,

int

age,

String

sex,

String

position)

{

super();

=

name;

this.age

=

age;

this.sex

=

sex;

this.position

=

position;

}

//

简化代码，省略setter和getter方法

@Override

public

String

toString()

{

return

"Employee{"

+

"name='"

+

name

+

'\''

+

",

age="

+

age

+

",

sex="

+

sex

+

",

position='"

+

position

+

'\''

+

"}";

}

}小民部门：public

class

CompanyMin

{

private

List<Employee>

list

=

new

ArrayList<>();

public

CompanyMin(){

list.add(new

Employee("小民",

26,

"男",

"程序猿"));

list.add(new

Employee("小芸",

22,

"女",

"测试"));

list.add(new

Employee("小方",

18,

"女",

"测试"));

list.add(new

Employee("可儿",

21,

"女",

"设计"));

list.add(new

Employee("朗情",

19,

"女",

"设计"));

//吐槽一下，为什么就小民一个男的，小辉部门全男的。

}

public

List<Employee>

getEmployees(){

return

list;

}

}小辉部门：public

class

CompanyHui

{

private

Employee[]

array

=

new

Employee[3];

public

CompanyHui(){

array[0]

=

new

Employee("辉哥",

28,

"男",

"程序猿");

array[1]

=

new

Employee("小红",

23,

"男",

"程序猿");

array[2]

=

new

Employee("小辉",

25,

"男",

"程序猿");

}

public

Employee[]

getEmployees(){

return

array;

}

}可见小民和小辉的内部实现是两种方式，小民的人员信息容器的内部实质是使用的一个List类存储人员信息，而小辉的实质上使用的是一个数组，如果老板要查看人员信息就必须遍历两个容器：Boss查看：public

class

Boss

{

public

static

void

main(String[]

args)

{

CompanyHui

hui

=

new

CompanyHui();

Employee[]

huiList

=

hui.getEmployees();

for(int

i

=

0;

i

<

huiList.length;

i++){

System.out.println(huiList[i]);

}

CompanyMin

min

=

new

CompanyMin();

List

minList

=

min.getEmployees();

for(int

i

=

0;

i

<

minList.size();

i++){

System.out.println(minList.get(i).toString());

}

}

}结果：Employee{name='辉哥',

age=28,

sex=男,

position='程序猿'}

Employee{name='小红',

age=23,

sex=男,

position='程序猿'}

Employee{name='小辉',

age=25,

sex=男,

position='程序猿'}

Employee{name='小民',

age=26,

sex=男,

position='程序猿'}

Employee{name='小芸',

age=22,

sex=女,

position='测试'}

Employee{name='小方',

age=18,

sex=女,

position='测试'}

Employee{name='可儿',

age=21,

sex=女,

position='设计'}

Employee{name='朗情',

age=19,

sex=女,

position='设计'}这样看似也没有问题，但是如果有多个部门，每个部门有各自的实现，那么我们就要在Boss类中增加一遍遍历逻辑，这样Boss类的功能会越来越多，同时暴露了内部细节。那么我们需要定义一个迭代器接口：public

interface

Iterator

{

/**

*

是否还有下一个元素

*

*

@return

true表示有，false表示没有

*/

boolean

hasNext();

/**

*

返回当前元素，并将位置移至下一位

*/

Object

next();

}小民的迭代器：public

class

MinIterator

implements

Iterator{

private

List<Employee>

list;

private

int

position;

public

MinIterator(List<Employee>

list){

this.list

=

list;

}

@Override

public

boolean

hasNext()

{

return

!(position

>

list.size()

-

1

||

list.get(position)

==

null);

}

@Override

public

Object

next()

{

Employee

e

=

list.get(position);

position++;

return

e;

}

}小辉的迭代器：public

class

HuiIterator

implements

Iterator{

private

Employee[]

array;

private

int

position;

public

HuiIterator(Employee[]

array){

this.array

=

array;

}

@Override

public

boolean

hasNext()

{

return

!(position

>

array.length

-

1

||

array[position]

==

null);

}

@Override

public

Object

next()

{

Employee

e

=

array[position];

position++;

return

e;

}

}定义容器类的接口：public

interface

Company

{

/**

*

返回一个迭代器对象

*

*

@return

迭代器对象

*/

Iterator

iterator();

}修改一下之前的两个容器类：public

class

CompanyHui

implements

Company{

private

Employee[]

array

=

new

Employee[3];

public

CompanyHui(){

array[0]

=

new

Employee("辉哥",

28,

"男",

"程序猿");

array[1]

=

new

Employee("小红",

23,

"男",

"程序猿");

array[2]

=

new

Employee("小辉",

25,

"男",

"程序猿");

}

public

Employee[]

getEmployees(){

return

array;

}

@Override

public

Iterator

iterator()

{

return

new

HuiIterator(array);

}

}public

class

CompanyMin

implements

Company{

private

List<Employee>

list

=

new

ArrayList<>();

public

CompanyMin(){

list.add(new

Employee("小民",

26,

"男",

"程序猿"));

list.add(new

Employee("小芸",

22,

"女",

"测试"));

list.add(new

Employee("小方",

18,

"女",

"测试"));

list.add(new

Employee("可儿",

21,

"女",

"设计"));

list.add(new

Employee("朗情",

19,

"女",

"设计"));

}

public

List<Employee>

getEmployees(){

return

list;

}

@Override

publi