Java集合、Iterator迭代器和增强for循环整理

集合

集合，集合是java中提供的一种容器，可以用来存储多个数据。

数组的长度是固定的。集合的长度是可变的。集合中存储的元素必须是引用类型数据

1.1      ArrayList集合存储元素

package com.oracle.List;

import java.util.List;

import java.util.ArrayList;

import java.util.Iterator;

public class Demo01 {

public static void main(String[] args) {

List<String> list=new ArrayList<String>();

list.add("a");

list.add("b");

list.add("c");

list.add(1,"e");

//遍历

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

System.out.println(list.get(i));

}

//删除指定位置上的元素

list.remove(0);

System.out.println("=========");

//遍历

for(String i : list){

System.out.println(i);

}

System.out.println("======================");

//修改指定位置上的元素

list.set(1, "你好吗？");

Iterator<String> it=list.iterator();

while(it.hasNext()){

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

}

}

}

运行结果：

1.2      集合的继承实现关系

查看ArrayList类发现它继承了抽象类AbstractList同时实现接口List，而List接口又继承了Collection接口

源代码：

interface List extends Collection {

}

public class ArrayList extends AbstractList implements List{

}

这说明我们在使用ArrayList类时，该类已经把所有抽象方法进行了重写。那么，实现Collection接口的所有子类都会进行方法重写。

Collection接口常用的子接口有：List接口、Set接口

List接口常用的子类有：ArrayList类、LinkedList类

Set接口常用的子类有：HashSet类、LinkedHashSet类

ArrayList ： 有序 可存储重复元素 增删快查找慢

LinkedArrayList ： 有序 可存储重复元素 查找快增删慢

HashiSet：无序  不可重复

LinkedHashiSet：有序 不可重复

1.3      Collection接口的基本方法

既然Collection接口是集合中的顶层接口，那么它中定义的所有功能子类都可以使用。查阅API中描述的Collection接口。Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

实体类：

package com.oracle.Collections;

public class Person {

private String name;

private int age;

public Person() {

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + age;

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Person other = (Person) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

}

package com.oracle.Collections;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class Demo01 {

public static void main(String[] args) {

List<Integer> list=new ArrayList<Integer>();

list.add(55);

list.add(53);

list.add(5);

list.add(52);

list.add(24);

list.add(44);

list.add(33);

//对数组进行排序

Collections.sort(list);

for(int i :list){

System.out.print(i+" ");

}

System.out.println();

//打乱集合元素的顺序

Collections.shuffle(list);

for(int i :list){

System.out.print(i+" ");

}

System.out.println();

}

}

运行结果：

package com.oracle.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

public class Demo02 {

private static Object classnames;

public static void main(String[] args) {

HashMap<String, HashMap<Person,String>> map=new HashMap<String, HashMap<Person,String>>();

HashMap<Person,String> m1=new HashMap<Person,String>();

HashMap<Person,String> m2=new HashMap<Person,String>();

m1.put(new Person("拉拉",22), "java1203班");

m1.put(new Person("欣欣",21), "java1203班");

m2.put(new Person("夏欣",18), "java1010班");

m2.put(new Person("小曦",24), "java1010班");

map.put("北大", m1);

map.put("清华", m2);

//key+增强for

/*Set<String> schools=map.keySet();

for(String school : schools){

//根据学校名称获取所哟有班级map

HashMap<Person, String> classes = map.get(school);

//遍历该班级的所有Set得到

Set<Person> persons=classes.keySet();

for(Person person:persons){

String classname=classes.get(persons);

System.out.println("学校名称为："+school+"，班级名称为："+person.getName()+"年龄为："+person.getAge());

}

}*/

Iterator<Map.Entry<String, HashMap<Person, String>>> it=map.entrySet().iterator();

while (it.hasNext()) {

//获取学校

Entry<String, HashMap<Person, String>> schools = it.next();

String schooler = schools.getKey();

HashMap<Person, String> classer = schools.getValue();

Iterator<Map.Entry<Person, String>> it1=classer.entrySet().iterator();

while (it1.hasNext()) {

Entry<Person, String> clas= it1.next();

Person key = clas.getKey();

String value = clas.getValue();

System.out.println(schooler+"  "+key.getName()+"  "+key.getAge());

}

}

}

}

运行结果：

Iterator迭代器

2.1    Iterator迭代器

Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

hasNext（）方法：用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代。

next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

迭代集合元素图解：

在Collection接口描述了一个抽象方法iterator方法，所有Collection子类都实现了这个方法，并且有自己的迭代形式

package com.oracle.demo01;

import java.util.Iterator;

import java.util.LinkedHashMap;

public class Demo02 {

public static void main(String[] args) {

LinkedHashMap<Person, String> map = new LinkedHashMap<Person, String>();

Person p1 = new Person("赵四", 18);

Person p2 = new Person("张三", 18);

Person p3 = new Person("熊大", 19);

map.put(p1, "Java1班");

map.put(p2, "Java2班");

map.put(p3, "Java3班");

//遍历

Iterator<Person> it=map.keySet().iterator();

while (it.hasNext()) {

Person key = it.next();

String value=map.get(key);

System.out.println(key+"   "+value);

}

}

}

运行结果：

2.2      集合元素的向下转型（强转）

在Collection接口描述了一个抽象方法iterator方法，所有Collection子类都实现了这个方法，并且有自己的迭代形式。

增强for循环

格式：

for(元素的数据类型 变量 : Collection集合or数组){

}

注意：新for循环必须有被遍历的目标。目标只能是Collection或者是数组。

建议：遍历数组时，如果仅为遍历，可以使用增强for如果要对数组的元素进行 操作，使用老式for循环可以通过角标操作。