javaSE第十五天

第十五天 117

1. 对象数组(掌握) 117

(1)定义： 117

(2)对象数组的内存图解 117

(3)案例： 117

2. 集合(Collection)(掌握) 119

(4)Collection的功能概述 120

(5)Collection集合的遍历 120

A:把集合转数组(了解)（toArray()方法的使用） 120

B:迭代器(集合专用方式) 121

C:for循环也可以遍历集合元素（不推荐） 122

(6)迭代器 124

(7)Collection集合的案例(遍历方式迭代器) 125

A:存储字符串并遍历 125

B:存储自定义对象并遍历 126

(8)Collection功能的代码演示 127

A）所有方法中，方法名后缀不带All的方法测试 127

B）所有方法中，方法名后缀带All的方法测试 130

3. 集合(List)(掌握) 131

(1)List是Collection的子接口 131

(2)List的特有功能： 132

(3)List集合的特有遍历功能 133

(4)列表迭代器listIterator的特有功能；(了解) 134

(5)并发修改异常（ConcurrentModificationException） 135

(6)常见数据结构 137

(7)List的子类特点(面试题) 137

(8)List集合的案例(遍历方式迭代器和普通for) 138

A:存储字符串并遍历 138

B:存储自定义对象并遍历 139

第十五天

1. 对象数组(掌握)

(1)定义：

数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。

(2)对象数组的内存图解

(3)案例：

用数组存储5个学生对象，并遍历数组。

import java.util.ArrayList;

import java.util.Collection;

* 练习：用集合存储5个学生对象，并把学生对象进行遍历。

* 分析：

* A:创建学生类

* B:创建集合对象

* C:创建学生对象

* D:把学生添加到集合

* E:把集合转成数组

* F:遍历数组

class StudentDemo {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

// 创建学生对象

Student s1 = new Student("林青霞", 27);

Student s2 = new Student("风清扬", 30);

Student s3 = new Student("令狐冲", 33);

Student s4 = new Student("武鑫", 25);

Student s5 = new Student("刘晓曲", 22);

// 把学生添加到集合

c.add(s1);

c.add(s2);

c.add(s3);

c.add(s4);

c.add(s5);

// 把集合转成数组

Object[] objs = c.toArray();

// 遍历数组

for (int x = 0; x < objs.length; x++) {

// System.out.println(objs[x]);

Student s = (Student) objs[x];

System.out.println(s.getName() + "---" + s.getAge());

}

2. 集合(Collection)(掌握)

(1)集合的由来?

我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组

而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。

(2)集合和数组的区别?

A:长度区别

数组固定

集合可变

B:内容区别

数组可以是基本类型，也可以是引用类型

集合只能是引用类型

C:元素内容

数组只能存储同一种类型

集合可以存储不同类型(其实集合一般存储的也是同一种类型)

(3)集合的继承体系结构?

由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，

但是它们都是要提供存储和遍历功能的，

我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

(4)Collection的功能概述

A:添加功能

boolean add(E e)：在集合的末尾添加一个元素

boolean addAll(Collection<? extends E> c)：添加一个集合的元素

，也就是在原集合中的后面追加一个集合

B:删除功能

void clear()：移除集合中所有元素

boolean remove(Object o)：移除一个指定的元素

boolean removeAll(Collection<?> c)：移除一个集合的元素，

（只要有一个元素被删除，就返回true）

C:判断功能

boolean contains(Object o)：判断集合中是否包含指定的元素

boolean containsAll(Collection<?> c)：判断集合中是否包含指定集合中的所有元素

（如果全部包含，就返回 true，否则返回false）

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

D:获取功能

Iterator<E> iterator()：迭代器遍历集合元素

E:长度功能

int size()：返回集合中元素的个数

F:交集(了解)

boolean retainAll(Collection<?> c)：获取两个集合的交集，

说明：假如有两个集合 A和B，

A对B做交集，最终的结果保存在A中，B不变

返回值：表示A集合是否发生过改变，如果改变，返回true

G:把集合转数组(了解)

Object[] toArray()：把集合转为数组

(5)Collection集合的遍历

A:把集合转数组(了解)（toArray()方法的使用）

import java.util.ArrayList;

import java.util.Collection;

* 集合的遍历。其实就是依次获取集合中的每一个元素。

* Object[] toArray():把集合转成数组，可以实现集合的遍历

CollectionDemo3 {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

// 添加元素

c.add("hello"); // Object obj = "hello"; 向上转型

c.add("world");

c.add("java");

// 遍历

// Object[] toArray():把集合转成数组，可以实现集合的遍历

Object[] objs = c.toArray();

for (int x = 0; x < objs.length; x++) {

// System.out.println(objs[x]);

// 我知道元素是字符串，我在获取到元素的的同时，还想知道元素的长度。

// System.out.println(objs[x] + "---" + objs[x].length());

// 上面的实现不了，原因是Object中没有length()方法

// 我们要想使用字符串的方法，就必须把元素还原成字符串

// 向下转型

String s = (String) objs[x];

System.out.println(s + "---" + s.length());

}

B:迭代器(集合专用方式)

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

* Iterator iterator():迭代器，集合的专用遍历方式

* Object next():获取元素,并移动到下一个位置。

* NoSuchElementException：报错，表示没有这样的元素，因为你已经找到最后了。

* boolean hasNext():如果仍有元素下一个元素可以迭代，则返回 true。

class IteratorDemo {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

// 创建并添加元素

// String s = "hello";

// c.add(s);

c.add("hello");

c.add("world");

c.add("java");

// Iterator iterator():迭代器，集合的专用遍历方式

Iterator it = c.iterator(); // 实际返回的肯定是子类对象，这里是多态

// Object obj = it.next();

// System.out.println(obj);

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

// 最后一个不应该写，所以，我们应该在每次获取前，如果有一个判断就好了

// 判断是否有下一个元素，有就获取，没有就不搭理它

// if (it.hasNext()) {

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

// }

// if (it.hasNext()) {

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

// }

// if (it.hasNext()) {

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

// }

// if (it.hasNext()) {

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

// }

// if (it.hasNext()) {

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

// }

// 最终版代码

while (it.hasNext()) {

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

String s = (String) it.next();

System.out.println(s);

}

C:for循环也可以遍历集合元素（不推荐）

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

* 问题1:能用while循环写这个程序，我能不能用for循环呢?

* 问题2:不要多次使用it.next()方法，因为每次使用都是访问一个对象。

class IteratorTest2 {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

// 创建学生对象

Student s1 = new Student("林青霞", 27);

Student s2 = new Student("风清扬", 30);

Student s3 = new Student("令狐冲", 33);

Student s4 = new Student("武鑫", 25);

Student s5 = new Student("刘晓曲", 22);

// 把学生添加到集合中

c.add(s1);

c.add(s2);

c.add(s3);

c.add(s4);

c.add(s5);

// 遍历//while循环写，层次清楚

Iterator it = c.iterator();

while (it.hasNext()) {

Student s = (Student) it.next();

System.out.println(s.getName() + "---" + s.getAge());

// NoSuchElementException 不要多次使用it.next()方法

//next()方法返回的是下一对象。

// System.out.println(((Student) it.next()).getName() + "---"

// + ((Student) it.next()).getAge());

}

// System.out.println("----------------------------------");

// for循环改写//效率高//层次不清楚

// for(Iterator it = c.iterator();it.hasNext();){

// Student s = (Student) it.next();

// System.out.println(s.getName() + "---" + s.getAge());

// }

}

(6)迭代器

A:是集合的获取元素的方式。

B:是依赖于集合而存在的。

C:迭代器的原理和源码。

a:为什么定义为了一个接口而不是实现类?

b:看了看迭代器的内部类实现。

//interator 的源码解析

//接口，该接口中定义了两个抽象方法

public interface Inteator {

boolean hasNext();

Object next();

}

//接口

public interface Iterable {

Iterator iterator();

}

//顶层集合接口Collection 继承 Iterable 接口

public interface Collection extends Iterable {

Iterator iterator();

}

public interface List extends Collection {

Iterator iterator();

}

//ArrayList子类实现 List接口

public class ArrayList implements List {

//同时也实现了 Iterator() 方法

public Iterator iterator() {

return new Itr();

}

//内部类实现了 Iterator 接口，并且私有，只允许外部类调用

private class Itr implements Iterator {

public boolean hasNext() {}

public Object next(){}

}

//案例：

Collection c = new ArrayList();

c.add("hello");

c.add("world");

c.add("java");

Iterator it = c.iterator(); //new Itr();

while(it.hasNext()) {

String s = (String)it.next();

System.out.println(s);

}

D:迭代器的原理图解

(7)Collection集合的案例(遍历方式迭代器)

集合的操作步骤：

A:创建集合对象

B:创建元素对象

C:把元素添加到集合

D:遍历集合

A:存储字符串并遍历

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

* 需求：存储字符串并遍历。

* 分析：

* A:创建集合对象

* B:创建字符串对象

* C:把字符串对象添加到集合中

* D:遍历集合

class CollectionTest {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

// 创建字符串对象

// 把字符串对象添加到集合中

c.add("林青霞");

c.add("风清扬");

c.add("刘意");

c.add("武鑫");

c.add("刘晓曲");

// 遍历集合

// 通过集合对象获取迭代器对象

Iterator it = c.iterator();

// 通过迭代器对象的hasNext()方法判断有没有元素

while (it.hasNext()) {

// 通过迭代器对象的next()方法获取元素

String s = (String) it.next();

System.out.println(s);

}

B:存储自定义对象并遍历

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

* 需求：存储自定义对象并遍历Student(name,age)

* 分析：

* A:创建学生类

* B:创建集合对象

* C:创建学生对象

* D:把学生对象添加到集合对象中

* E:遍历集合

class CollectionTest2 {

public static void main(String[] args) {

// 创建集合对象

Collection c = new ArrayList();

// 创建学生对象

Student s1 = new Student("貂蝉", 25);

Student s2 = new Student("小乔", 16);

Student s3 = new Student("黄月英", 20);

Student s4 = new Student();

s4.setName("大乔");

s4.setAge(26);

// 把学生对象添加到集合对象中.

c.add(s1);

c.add(s2);

c.add(s3);

c.add(s4);

c.add(new Student("孙尚香", 18)); // 匿名对象

// 遍历集合

Iterator it = c.iterator();

while (it.hasNext()) {

Student s = (Student) it.next();

System.out.println(s.getName() + "---" + s.getAge());

}

(8)Collection功能的代码演示

A）所有方法中，方法名后缀不带All的方法测试

import java.util.ArrayList;

import java.util.Collection;

* 集合的由来：

* 我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。

* 而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?

* 数组和StringBuffer。但是呢?StringBuffer的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。

* 而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用。

* 数组和集合的区别?

* A:长度区别

* 数组的长度固定

* 集合长度可变

* B:内容不同

* 数组存储的是同一种类型的元素

* 而集合可以存储不同类型的元素

* C:元素的数据类型问题

* 数组可以存储基本数据类型，也可以存储引用数据类型

* 集合只能存储引用类型

* 刚说过集合是存储多个元的，但是呢，存储多个元素我们也是有不同需求的：比如说，我要这多个元素中不能有相同的元素，

* 再比如说，我要这多个元素按照某种规则排序一下。针对不同的需求，Java就提供了不同的集合类，这样呢，Java就提供了很多个集合类。

* 这多个集合类的数据结构不同,结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说判断，获取等。

* 既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构。

* 数据结构：数据的存储方式。

* Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)

* Collection的功能概述：

* 1：添加功能

* boolean add(Object obj):添加一个元素

* boolean addAll(Collection c):添加一个集合的元素

* 2:删除功能

* void clear():移除所有元素

* boolean remove(Object o):移除一个元素

* boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)

* 3:判断功能

* boolean contains(Object o)：判断集合中是否包含指定的元素

* boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)

* boolean isEmpty()：判断集合是否为空

* 4:获取功能

* Iterator<E> iterator()(重点)

* 5:长度功能

* int size():元素的个数

* 面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?

* 6:交集功能

* boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

* 7：把集合转换为数组

* Object[] toArray()

class CollectionDemo {

public static void main(String[] args) {

// 测试不带All的方法

// 创建集合对象

// Collection c = new Collection(); //错误，因为接口不能实例化

Collection c = new ArrayList();

// boolean add(Object obj):添加一个元素

// System.out.println("add:"+c.add("hello"));

c.add("hello");

c.add("world");

c.add("java");

// void clear():移除所有元素

// c.clear();

// boolean remove(Object o):移除一个元素

// System.out.println("remove:" + c.remove("hello"));

// System.out.println("remove:" + c.remove("javaee"));

// boolean contains(Object o)：判断集合中是否包含指定的元素

// System.out.println("contains:"+c.contains("hello"));

// System.out.println("contains:"+c.contains("android"));

// boolean isEmpty()：判断集合是否为空

// System.out.println("isEmpty:"+c.isEmpty());

// int size():元素的个数

System.out.println("size:" + c.size());

System.out.println("c:" + c);

}

B）所有方法中，方法名后缀带All的方法测试

import java.util.ArrayList;

import java.util.Collection;

* boolean addAll(Collection c):添加一个集合的元素

* boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)

* boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)

* boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

class CollectionDemo2 {

public static void main(String[] args) {

// 创建集合1

Collection c1 = new ArrayList();

c1.add("abc1");

c1.add("abc2");

c1.add("abc3");

c1.add("abc4");

// 创建集合2

Collection c2 = new ArrayList();

// c2.add("abc1");

// c2.add("abc2");

// c2.add("abc3");

// c2.add("abc4");

c2.add("abc5");

c2.add("abc6");

c2.add("abc7");

// boolean addAll(Collection c):添加一个集合的元素

// System.out.println("addAll:" + c1.addAll(c2));

// boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)

// 只要有一个元素被移除了，就返回true。

// System.out.println("removeAll:"+c1.removeAll(c2));

// boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)

// 只有包含所有的元素，才叫包含

// System.out.println("containsAll:"+c1.containsAll(c2));

// boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

// 假设有两个集合A，B。

// A对B做交集，最终的结果保存在A中，B不变。

// 返回值表示的是A是否发生过改变。

System.out.println("retainAll:" + c1.retainAll(c2));

System.out.println("c1:" + c1);

System.out.println("c2:" + c2);

}

3. 集合(List)(掌握)

(1)List是Collection的子接口

特点：有序(存储顺序和取出顺序一致)，可重复。

* List集合的特点：

* 有序(存储和取出的元素一致)，可重复的。

class ListDemo2 {

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 存储元素

list.add("hello");

list.add("world");

list.add("java");

list.add("javaee");

list.add("android");

list.add("javaee");

list.add("android");

// 遍历集合

Iterator it = list.iterator();

while (it.hasNext()) {

String s = (String) it.next();

System.out.println(s);

}

(2)List的特有功能：

A:添加功能

public void add(int index, E element):在指定的位置添加元素

B:删除功能

public E remove(int index)：根据索引删除元素，返回被删除的元素

C:获取功能

public E get(int index)：获取指定位置的元素

D:迭代器功能

public ListIterator<E> listIterator(int index)：List集合特有的迭代器

E:修改功能

public E set(int index, E element)：根据索引修改元素，返回被修改的元素

F:各功能方法演示

import java.util.ArrayList;

import java.util.List;

* List集合的特有功能：

* A:添加功能

* void add(int index,Object element):在指定位置添加元素

* B:获取功能

* Object get(int index):获取指定位置的元素

* C:列表迭代器

* ListIterator listIterator()：List集合特有的迭代器

* D:删除功能

* Object remove(int index)：根据索引删除元素,返回被删除的元素

* E:修改功能

* Object set(int index,Object element):根据索引修改元素，返回被修改的元素

class ListDemo {

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 添加元素

list.add("hello");

list.add("world");

list.add("java");

// void add(int index,Object element):在指定位置添加元素

// list.add(1, "android");//没有问题

// IndexOutOfBoundsException

// list.add(11, "javaee");//有问题

// list.add(3, "javaee"); //没有问题

// list.add(4, "javaee"); //有问题

// Object get(int index):获取指定位置的元素

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

// IndexOutOfBoundsException

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

// Object remove(int index)：根据索引删除元素,返回被删除的元素

// System.out.println("remove:" + list.remove(1));

// IndexOutOfBoundsException

// System.out.println("remove:" + list.remove(11));

// Object set(int index,Object element):根据索引修改元素，返回被修改的元素

System.out.println("set:" + list.set(1, "javaee"));

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

}

(3)List集合的特有遍历功能

A:由size()和get()结合。

B:代码演示

import java.util.ArrayList;

import java.util.List;

* List集合的特有遍历功能：

* size()和get()方法结合使用

class ListDemo2 {

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 添加元素

list.add("hello");

list.add("world");

list.add("java");

// Object get(int index):获取指定位置的元素

// System.out.println(list.get(0));

// System.out.println(list.get(1));

// System.out.println(list.get(2));

// IndexOutOfBoundsException

// System.out.println(list.get(3));

// 用循环改进

// for (int x = 0; x < 3; x++) {

// System.out.println(list.get(x));

// }

// 如果元素过多，数起来就比较麻烦，所以我们使用集合的一个长度功能：size()

// 最终的遍历方式就是：size()和get()

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

// System.out.println(list.get(x));

String s = (String) list.get(x);

System.out.println(s);

}

(4)列表迭代器listIterator的特有功能；(了解)

可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

* 列表迭代器：

* ListIterator listIterator()：List集合特有的迭代器

* 该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法。

* 特有功能：

* Object previous():获取上一个元素

* boolean hasPrevious():判断是否有元素

* 注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。

class ListIteratorDemo {

public static void main(String[] args) {

// 创建List集合对象

List list = new ArrayList();

list.add("hello");

list.add("world");

list.add("java");

// ListIterator listIterator()

ListIterator lit = list.listIterator(); // 子类对象

while (lit.hasNext()) {

String s = (String) lit.next();

System.out.println(s);

}

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

while (lit.hasPrevious()) {

String s = (String) lit.previous();

System.out.println(s);

}

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

// 迭代器

Iterator it = list.iterator();

while (it.hasNext()) {

String s = (String) it.next();

System.out.println(s);

}

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

}

(5)并发修改异常（ConcurrentModificationException）

A:出现的现象

迭代器遍历集合，集合修改集合元素

B:原因

迭代器是依赖于集合的，而集合的改变，迭代器并不知道。

C:解决方案

a:迭代器遍历，迭代器修改(ListIterator)

元素添加在刚才迭代的位置

b:集合遍历，集合修改(size()和get())

元素添加在集合的末尾

D:代码演示

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

* 问题?

* 我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

* ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

* 产生的原因：

* 迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。

* 其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。

* 如何解决呢?

* A:迭代器迭代元素，迭代器修改元素

* 元素是跟在刚才迭代的元素后面的。

* B:集合遍历元素，集合修改元素(普通for)

* 元素在最后添加的。

class ListIteratorDemo2 {

public static void main(String[] args) {

// 创建List集合对象

List list = new ArrayList();

// 添加元素

list.add("hello");

list.add("world");

list.add("java");

// 迭代器遍历

// Iterator it = list.iterator();

// while (it.hasNext()) {

// String s = (String) it.next();

// if ("world".equals(s)) {

// list.add("javaee");

// }

// 方式1：迭代器迭代元素，迭代器修改元素

// 而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator

// ListIterator lit = list.listIterator();

// while (lit.hasNext()) {

// String s = (String) lit.next();

// if ("world".equals(s)) {

// lit.add("javaee");

// }

// 方式2：集合遍历元素，集合修改元素(普通for)

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

String s = (String) list.get(x);

if ("world".equals(s)) {

list.add("javaee");

}

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

}

(6)常见数据结构

A:栈先进后出

B:队列先进先出

C:数组查询快，增删慢

D:链表查询慢，增删快

E：数据结构之数组和链表结构图解

F:数据结构之栈和队列结构图解

(7)List的子类特点(面试题)

List:(面试题List的子类特点)

ArrayList:

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

Vector:

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

LinkedList:

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

List有三个儿子，我们到底使用谁呢?

看需求(情况)。

要安全吗?

要：Vector(即使要安全，也不用这个了，后面有替代的)

不要：ArrayList或者LinkedList

查询多：ArrayList

增删多：LinkedList

如果你什么都不懂，就用ArrayList。

(8)List集合的案例(遍历方式迭代器和普通for)

A:存储字符串并遍历

import java.util.ArrayList;

import java.util.List;

* List集合的特有遍历功能：

* size()和get()方法结合使用

class ListDemo2 {

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 添加元素

list.add("hello");

list.add("world");

list.add("java");

// 最终的遍历方式就是：size()和get()

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

// System.out.println(list.get(x));

String s = (String) list.get(x);

System.out.println(s);

}

B:存储自定义对象并遍历

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

* List集合的特有遍历功能：

size()和get()方法结合使用

* 存储自定义对象并遍历,用普通for循环。(size()和get()结合)

class ListDemo3 {

public static void main(String[] args) {

// 创建集合对象

List list = new ArrayList();

// 创建学生对象

Student s1 = new Student("林黛玉", 18);

Student s2 = new Student("刘姥姥", 88);

Student s3 = new Student("王熙凤", 38);

// 把学生添加到集合中

list.add(s1);

list.add(s2);

list.add(s3);

// 遍历

// 迭代器遍历

Iterator it = list.iterator();

while (it.hasNext()) {

Student s = (Student) it.next();

System.out.println(s.getName() + "---" + s.getAge());

}

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

// 普通for循环

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

Student s = (Student) list.get(x);

System.out.println(s.getName() + "---" + s.getAge());

}