※ 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。※数组中可以存储基本数据类型，集合只能存储对象。
public static void base_method()
{
//创建集合容器，使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1.添加元素
al.add("java01");//add(Object obj)
al.add("java02");
al.add("java03");
al.add("java04");
//打印集合
sop(al);
//2.获取个数，集合长度
sop("size:"+al.size());
//3.删除元素
al.remove("java02"); //al.clear(); 清空集合
sop(al);
//4.判断元素
sop("java03是否存在？ "+al.contains("java03"));
sop("集合是否为空？ "+al.isEmpty());
}
<pre name="code" class="java">public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
al1.retainAll(al2); //取交集，al1中只会存储和al2相同的元素
al1.removeAll(al2); //去交集，al1中只会存储和al2不相同的元素
sop("al1:"+al1+" al2:"+al2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}（1）迭代器是取出集合中元素的方式
对于集合的元素取出这个动作：当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述，把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样，但都具有共性内容：判断和取出，那么就可以将这些共性抽取。这些内部类都符合一个规则（或者说都抽取出来一个规则），就是Iterator，并通过一个对外提供的方法：iterator(); 来获取集合的取出对象。
（2） 迭代的常见操作※ 因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
hasNext();//有下一个元素，返回真，作为迭代器的条件
next();//取出下一个元素
remove();//移除
※ 在迭代时循环中next调用一次，就要hasNext判断一次。
两种表现形式：
a.
b.for(Iterator iter = a.iterator();iter.hasNext(); ) { <span style="white-space:pre"> </span>System.out.println(iter.next()); }
Iteratoriter = a.iterator(); while(iter.hasNext()) { <span style="white-space:pre"> </span>System.out.println(iter.next()); }
三、List集合
1. 概述：元素是有序的，可以重复，因为该集合体系有索引
List
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
2. 特有方法：
※ 凡是可以操作角标的方法都是该体系特有的方法。
（1）增
booleanadd(index,element); 指定位置添加元素
BooleanaddAll(index,Collection); 在指定位置增加给定集合中的所有元素
若省略位置参数，则在当前集合的后面依次添加元素
（2）删
Booleanremove(index); 删除指定位置的元素
（3）改
set(index,element); 修改指定位置的元素。
（4）查
get(index); 通过角标获取元素
subList(from,to); 获取部分对象元素
（5）其他
listIterator(); List特有的迭代器（Iterator迭代时不可以通过集合对象的方法操作集合中的元素）
可以在迭代时对集合元素进行增、删、改、查
indexOf(obj); 获取元素第一次出现的位置，如果没有则返回-1
※ List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
3. LinkedList特有方法：
（1）增
addFirst();
addLast();
（2）获取：获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
（3）删：获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
※ 在JDK1.6以后，出现了替代方法。
（1）增
offFirst();
offLast();
（2）获取：获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
（3）删：获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
例：
<span style="white-space:pre"> </span>public class LinkedListDemo
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>public static void main(String[] args)
<span style="white-space:pre"> </span>{
LinkedList link = new LinkedList();
link.addFirst("java01");//addFirst：04.03.02.01，addLast：01.02.03.04
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst());
sop(link.getLast());
sop(link.removeFirst());//先进后出；removeLast先进先出
sop("size="+link.size());
while(!link.isEmpty())
{
sop(link.removeFirst()); //正向取。 removeLast反向取
}
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>public static void sop(Object obj)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>System.out.println(obj);
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>}练习：
class Person{private String name;private int age;public boolean equals(Object obj)//重写equals方法{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;}Person(String name,int age){this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}}public class ArrayListTest2{public static void main(String[] args) {ArrayList al = new ArrayList();al.add(new Person("lisi01",30));al.add(new Person("lisi02",32));al.add(new Person("lisi02",32));al.add(new Person("lisi03",33));al.add(new Person("lisi04",35));al.add(new Person("lisi04",35));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)) //contains调用的是Person的equals方法newAl.add(obj);}return newAl;}public static void sop(Object obj){System.out.println(obj);}}/* * 将自定义对象作为元素，存储到ArrayList集合中，并去除重复元素 * 比如：人对象：同姓名同年龄视为同一个人，为重复元素 * * 思路：1.对人描述，将数据封装进人对象 * 2.定义容器，将人存入 * 3.取出 * * List集合判断元素是否相同，依据是元素的equals方法。 */ <pre name="code" class="java" style="line-height: 26px;">import java.util.*;
※ 增删操作频繁，使用LinkedList；增删操作不频繁，两者都可用；增删和查询操作同时涉及，使用ArrayList
※ ArrayList更常用
四、Set
1. 概述：元素是无序（存入和取出的顺序不一定一致）的，且不可以重复。
Set
|--HashSet
|--TreeSet
※ Set集合的功能和Collection是一致的。
2. HashSet：底层数据结构是哈希表，线程不同步。
例：保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为 true（ArrayList判断只依赖equals）
class HashSetTest{public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("a1",11));hs.add(new Person("a2",12));hs.add(new Person("a3",13));hs.add(new Person("a2",12));hs.add(new Person("a4",14));sop("a1:"+hs.contains(new Person("a1",11)));sop("a3:"+hs.remove(new Person("a3",13)));Iterator it = hs.iterator();while(it.hasNext()){Person p = (Person)it.next();sop(p.getName()+"::"+p.getAge());}}public static class Person{private String name;private int age;Person(String name,int age){this.name = name;this.age = age;}public int hashCode() //复写Object类的hashCode()方法{System.out.println(this.name+".....hashCode");return name.hashCode()+age*39; //为了尽量保证哈希值唯一*39}public boolean equals(Object obj)//复写equals()方法{if(!(obj instanceof Person))return false;Person p = (Person)obj;System.out.println(this.name+"...equals..."+p.name);return this.name.equals(p.name)&&this.age==p.age;//先判断姓名，再判断年龄}public String getName() {return name;}public int getAge() {return age;}}}/* * 往HashSet集合中存入自定义对象 * 姓名和年龄相同为同一个人，重复元素 */ <pre name="code" class="java" style="line-height: 26px;">import java.util.*;
3. TreeSet：
※ 底层数据结构是二叉树，可以对Set集合中的元素进行排序，默认按照字母的自然排序。
※ 保证元素唯一性的依据：compareTo方法，return 0
※ 排序方式：
（1）第一种方式：让元素自身具备比较性，元素需要实现comparable接口，覆盖compareTo方法也称为元素的自然排序，或叫做默认顺序。
例：
/* * 给TreeSet集合中存储自定义对象学生，按年龄排序 */ import java.util.*; public class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi08",19)); ts.add(new Student("lisi08",19)); Iterator it = ts.iterator(); while(it.hasNext()) { Student stu = (Student)it.next(); System.out.println(stu.name+"..."+stu.age); } } public static class Student implements Comparable //该接口强制让学生具备比较性 { private String name; private int age; Student(String name,int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { //return 0; if(!(obj instanceof Student)) throw new RuntimeException("不是学生对象"); Student s = (Student)obj; System.out.println(this.name+"...comapreto..."+s.name); if(this.age>s.age) return 1; if(this.age==s.age) return this.name.compareTo(s.name); return -1; } public String getName() { return name; } public int getAge() { return age; } } }（2）第二种方式：比较器，当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式，定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
※ 比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
※ 排序时，当主要条件相同时，一定要判断次要条件
※ 当两种排序都存在时，以比较器为主
例：
import java.util.*; class TreeSetDemo2 { public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student("lisi01",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi08",18)); ts.add(new Student("lisi007",29)); Iterator it = ts.iterator(); while(it.hasNext()) { Student stu = (Student)it.next(); System.out.println(stu.getName()+"..."+stu.getAge()); } } } class Student implements Comparable //该接口强制让学生具备比较性 { private String name; private int age; Student(String name,int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { // return 0; if(!(obj instanceof Student)) throw new RuntimeException("不是学生对象"); Student s = (Student)obj; System.out.println(this.name+"...comapreto..."+s.name); if(this.age>s.age) return 1; if(this.age==s.age) return this.name.compareTo(s.name); return -1; } public String getName() { return name; } public int getAge() { return age; } }
五、泛型
1. 概念：JDK1.5版本后出现的新特性，用于解决安全问题，是一个安全机制
2. 好处：
（1）将运行时期出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全
（2）避免了强制转换
3. 泛型格式：通过<>来定义要操作的引用数据类型
※ 在使用java提供的对象时，什么时候写泛型：通常在集合框架中很常见，只要见到<>就要定义泛型
※ 其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
例：
4. 泛型public class GenericDemo { public static void main(String[] args) { ArrayList<String> al = new ArrayList<String>();//泛型 al.add("abc01"); al.add("abc0991"); al.add("abc014"); Iterator<String> it = al.iterator(); while(it.hasNext()) { String s = it.next(); System.out.println(s+":"+s.length()); } } }（1）泛型类：当类中要操作的引用数据类型不确定时，定义泛型类。
例：
class Utils<QQ> { private QQ q; public void setObject(QQ q) { this.q = q; } public QQ getObject() { return q; } }（2）泛型方法：泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上
※ 静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
※ 定义泛型放在返回值前面
例：
（3）泛型限定：（用于进行泛型扩展）class Demo { public <T> void show(T t) { System.out.println("show:"+t); } public <Q> void print(Q q) { System.out.println("print:"+q); } }
? extends E：可以接收E类型或者E的子类型。（上限）
? super E：可以接收E类型或者E的父类型。（下限）
※ "?"通配符，也可以理解为占位符
六、Map集合
1. 概述：Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，
即键（Key）
※ 该集合存储键值对，一对一对往里存
2. Map※ 要保证键的唯一性。
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值（该集合是线程同步的）
|--Hashmap：底层是哈希表数据结构，允许使用null键null值（该集合是不同步的）
|--Treemap ：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键排序
※ 和Set很像，其实Set底层就是使用的Map集合。
3. 常用方法
（1）添加： put(K key,V value);
putAll(Map<? extends K , ? extends V>m);
（2）删除：clear();
remove(Object key);
（3）判断：containsValue(Object value);
containsKey(Object key);
isEmpty();
（4）获取：get (Object key);
size();
values();
※ keySet(); 将map中的所有键存入到Set集合，因为Set有迭代器，通过迭代器取出所有的键
再通过get方法获取每个键的对应值
entrySet(); 将map中的映射关系取出，存入到set集合
例：
/* * 每一个学生都有对应的归属地。 * 学生Student，地址String * 学生属性：姓名，年龄。姓名和年龄相同的视为同一个学生，保证学生唯一性 * * 1.描述学生 * 2.定义map容器，将学生作为键，地址作为值，存入 * 3.获取map集合中的元素 */ import java.util.*; class Student implements Comparable<Student> { private String name;//描述学生属性 private int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } public int compareTo(Student s)//复写compareTo方法 { int num = new Integer(this.age).compareTo(new Integer(s.age)); if(num==0) return this.name.compareTo(s.name); return num; } //复写hashCode方法 public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } //复写equals方法 public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (!(obj instanceof Student)) throw new ClassCastException("类型不匹配"); Student other = (Student) 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; } public String getName() { return name; } public int getAge() { return age; } public String toString() { return name+":"+age; } } public class MapTest { public static void main(String[] args) { HashMap<Student,String> hm = new HashMap<Student,String>(); hm.put(new Student("lisi1",21), "beijing");//添加元素 hm.put(new Student("lisi1",21), "tianjin");//会覆盖前一个 hm.put(new Student("lisi2",22), "shanghai"); hm.put(new Student("lisi3",23), "nanjing"); hm.put(new Student("lisi4",24), "wuhan"); //第一种取出方式 keySet Set<Student> keySet = hm.keySet();//获取map集合所有键的Set集合 Iterator<Student> it = keySet.iterator();//获取其迭代器 while(it.hasNext()) { Student stu = it.next(); String addr = hm.get(stu);//有了键，通过map集合的get方法获取其对应的值 // System.out.println(stu+".."+addr); } //第二种取出方式 entrySet Set<Map.Entry<Student, String>> entrySet = hm.entrySet();//取出映射关系 Iterator<Map.Entry<Student, String>> iter = entrySet.iterator(); while(iter.hasNext()) { Map.Entry<Student, String> me = iter.next(); Student stu = me.getKey(); String addr = me.getValue(); System.out.println(stu+".."+addr); } } }※ 关于Map.Entry：
Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。
※ 为何要定义在其内部的原因：
a.Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b.并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。
4. TreeMap：用于给Map集合中的键排序
例：
5.Map集合扩展：/* 需求：对学生对象的年龄进行升序排序 因为数据是以键值对形式存在的，所以使用可以排序的Map集合，TreeMap */ import java.util.*; class MapTest2 { public static void main(String[] args) { TreeMap<Students,String> t = new TreeMap<Students,String>(new StuNameComparator()); t.put(new Student("lisi1",21), "beijing"); t.put(new Student("lisi2",22), "shanghai"); t.put(new Student("lisi3",23), "nanjing"); t.put(new Student("lisi4",24), "wuhan"); Set<Map.Entry<Students,String>> entrySet = t.entrySet(); Iterator<Map.Entry<Students,String>> it = entrySet.iterator(); while(it.hasNext()) { Map.Entry<Students,String> me = it.next(); Student stu = me.getKey(); String addr = me.getValue(); System.out.println(stu+":::"+addr); } } } //学生类同上 //自定义比较器，比较姓名 class StuNameComparator implements Comparator<Student> { public int compare(Student s1,Student s2) { int num = s1.getName().compareTo(s2.getName()); if(num==0) return new Integer(s1.getAge()).compareTonew Integer(s2.getAge())); return num; } }在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。
例：
/* map扩展知识。 map集合被使用是因为具备映射关系。 以下是班级对应学生，而学生中学号对应着姓名的映射关系： "yureban" Student("01" "zhangsan"); "yureban" Student("02" "lisi"); "jiuyeban" "01" "wangwu"; "jiuyeban" "02" "zhaoliu"; 就如同一个学校有多个教室。每一个教室都有名称。 */ import java.util.*; class MapExpandKnow { public static void main(String[] args) { //预热班集合 HashMap<String,String> yureban=new HashMap<String,String>(); //就业班集合 HashMap<String,String> jiuyeban=new HashMap<String,String>(); //学校集合 <span style="white-space:pre"> </span>HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>(); //学校中班级集合和名称的映射 czbk.put("yureban",yureban); czbk.put("jiuyueban",jiuyeban); <span style="white-space:pre"> </span>//预热班级中学号与姓名的映射 yureban.put("01","zhangsan"); yureban.put("02","lisi"); //就业班级中学号与姓名的映射 jiuyeban.put("01","wangwu"); jiuyeban.put("02","zhouqi"); <span style="white-space:pre"> </span>//直接显示全部学生信息 getAllStudentInfo(czbk); } //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少 public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm) { for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式 { String s= it.next();//班级名称 System.out.println(s+":"); HashMap<String,String> stu=hm.get(s);//班级集合 getStudentInfo(stu); } } //获取班级中学生的信息，包括姓名和学号 public static void getStudentInfo(HashMap<String,String> hm) { for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; ) { String key=it.next();//学号 String value=hm.get(key);//姓名 System.out.println(key+"..."+value); } } }
七、集合框架工具类
1. Collections
（1）概述：Collections是对集合框架的一个工具类。它里边的方法都是静态的，不需要创建对象，并未封装特有数据。
在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。
（2）常见操作：
a.查找
Tmax(Collection<? extends T> coll);
（根据集合的自然顺序，获取coll集合中的最大元素）
Tmax(Collection<? extends T> coll,Comparator<? super T> comp);
（根据指定比较器comp的顺序，获取coll集合中的最大元素）
intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);
（二分法搜索list集合中的指定对象）
b.替换
voidfill(List<? super T> list, T obj);
（将list集合中的全部元素替换成指定对象obj）
booleanreplaceAll(List<T> lsit,T oldVal,T newVal);
（用newVal替换集合中的oldVal值）
void swap(Listlist,int i,int j);
（在指定列表的指定位置处交换元素）
c.排序
void shuffle(List<?> list);
（使用默认随机源对list集合中的元素进行随机排序）
void sort(Lsit<T> list);
（根据自然顺序对list集合中的元素进行排序）
voidsort(List<T> lsit,Comparator<? super T> c);
（根据指定比较器c的排序方式对list集合进行排序）
d.反转
reverse(List<?> list);
（反转list集合中元素的顺序）
Comparator reverseOrder();
（返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序）
ComparatorreverseOrder(Comparator<T> cmp);
（返回一个比较器，强行逆转了指定比较器的顺序）
e.同步的集合
List<T>synchronizedList(List<T> list);
（返回支持的同步（线程安全的）List集合）
Map<K,V>synchronizedList(Map<K,V> m);
（返回支持的同步（线程安全的）Map集合）
（3）与Collection的区别：
Colletion是java.util包中的接口，是集合类的基本接口，主要的子接口有list和set，都可以使用迭代器对集合进行遍历
Collections是java.util包中的类，是针对集合的一个实用工具类，包含对各种集合的搜索、查询、修改、排序、线程安全等一系列的静态方法。
2. Arrays
（1）概述：Arrays是用于操作数组的工具类，里边的方法也全是静态的，不需要创建对象。
把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。
如：contains，get，indexOf，subList等方法。
（2）常见方法
a. Lsit<T> asList(T... a); （将数组转换为集合）
※ 将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。
※ 如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
※ 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
b. binarySearch(); （二分查找方法，fill()：替换方法，sort()：排序方法等）
※ 可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。
如：sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
c. String toString(); （可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式）
（3）集合变数组
Collection接口中的toArray方法。
<T> T[] toArray (T[] a);（将集合变为指定类型的数组）
a. 指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
b. 将集合变数组：为了限定对元素的操作，不再需要进行增删。
八、扩展知识——1.5版本新特性
1. 高级for
（1）格式：for(数据类型变量名 :被遍历的集合（collection）或者数组) {执行语句}
※ 对集合进行遍历，只能获取集合元素，不能对集合进行操作，可以看作是迭代器的简写形式。
※ 迭代器除了遍历，还可以进行remove集合中元素的动作；如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。
（2）传统for和高级for的区别：
高级for有一个局限性，必须有被遍历的目标（集合或数组）。
传统for遍历数组时有索引。
建议在遍历数组的时候，使用传统for，因为传统for可以定义角标。
例：
for(int i : arr) { System.out.println("i:"+i); }
2. 方法的可变参数
如果一个方法在参数列表中传入多个参数，个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。在JDK1.5版本后，就提供了一个新特性：可变参数。
可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
例：
class ParamMethodDemo { public static void main(String[] args) { show("hehe",2,3,4,5,6); } public static void show(String str,int... arr)//...就表示可变参数 { System.out.println(arr.length); } }
※ 可变参数一定要定义在参数列表的最后面。
3. 静态导入
（1）格式：
import static java.util.Arrays.*;（导入的是Arrays这个类中的所以静态成员）
import static java.lang.System.*;（导入了Ssytem类中所以静态成员）
※ 没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。
※ 这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);
※ 当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
※ 当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。
74
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
