java集合List

需求：List集合存储字符串并遍历。
List集合的特点：
有序(存储和取出的元素一致)，可重复的。
package javatest;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class A {

public static void main(String[] args) {
// 创建集合对象
List list = new ArrayList();

// 创建字符串并添加字符串
list.add("hello");
list.add("world");
list.add("java");
list.add("hello1");
list.add("world2");
list.add("java3");

// 遍历数组
Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
}
}
}
最后输出
hello
world
java
hello1
world2
java3

---------------------------------------------------------------------------------
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):根据索引修改元素，返回被修饰的元素

public static void main(String[] args){
//创建集合对象
List list = new ArrayList();

//添加元素
list.add("hello");
list.add("world");
list.add("java");

1 //void add(int index,Object element):在指定位置添加元素
list.add(1."android");//注意 索引不可越界 但是在这里可以是3 将android成为第四个元素

System.out.println("list:"+list);list:[hello,android,world,java]

2 //Object get(int index):获取指定位置的元素
System.out.println("get:"+list.get(1)); //get:world //不可越界

3 //ListIterator listIterator():List集合特有的迭代器

4 //Object remove(int index):根据索引删除元素，返回被删除的元素
System.out.println("remove:"+list.remove(1));remove:world//不可越界
System.out.println("list:"+list);list:[hello,java]

5 //Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
System.out.println("set:"+list.set(1,"javaee"));set:world
System.out.println("list:"+list);//[hello,javaee,java]
}

List集合的特有遍历功能：
size()和get()方法结合

public static void main(String[] args){
//创建对象
List list = new ArrayList();

//添加元素
list.add("hello");
list.add("world");
list.add("java");

//for(int x=0;x<list.size;x++){
String s = (String)list.get(x);
System.out.println(s);
}
}

//List存储自定义对象并遍历
测试类
package javatest;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class A {

public static void main(String[] args) {
// 创建集合对象
List list = new ArrayList();

AText s1 = new AText("林黛玉", 18);
AText s2 = new AText("刘奶奶", 88);
AText s3 = new AText("王熙凤", 38);

// 把AText添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);

// 迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
AText s = (AText) it.next();
System.out.println(s);
}

// 普通for循环
for (int x = 0; x < list.size(); x++) {
AText s = (AText) list.get(x);
System.out.println(s);
}

}

}

工具类
package javatest;

public class AText {
// 成员变量
private String name;
private int age;

// 构造方法
public AText() {
super();

}

public AText(String name, int age) {
super();
this.name = name;
this.age = age;
}

// get方法set方法
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 "Student: [name=" + name + ",age=" + age + "]";
}

}

ListIterator的特有功能(列表迭代器)：
列表迭代器：ListIterator listIterator():List集合特有的迭代器
//该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法
//特有功能：
Object previous():获取上一个元素
boolean hasPrevious():判断是否有元素

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

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

//迭代器
Iterator it = list.iterator();
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s);
}

//逆向遍历
while(lit.hasPrevious()){
String s = (String)lit.previous();
System.out.println(s);
}
}

问题：
我有一个集合，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javeee"元素，代码实现

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");
}
}
System.out.println(list);
}

结果报错了：ConcurrentModificationException：当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
产生原因：
迭代器是依赖集合而存在的，在判断成功后，集合中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。
如何解决呢？
//这两种方法都可以改集合元素，都可以避免并发修改异常的报错
A:迭代器迭代元素，迭代器修改元素。
元素是跟在刚才迭代的元素后面的。
B:集合遍历元素，集合修改元素。(普通for)
元素在最后添加的。

方式A：迭代器迭代元素，迭代器修改元素
而Iterator迭代器却没有添加功能，所以我们使用其子接口ListIterator
ListIterator lit = list.listIterator();
while(lit.hasNext()){
String s = (String)lit.next();
if("world".equals(s)){
lit.add("javaee")
}
}
System.out.println(list);//[hello, world, javaee, java]

方式B:集合遍历元素，集合修改元素。(普通for)
for(int x<0;x<list.size();x++){
String s = (String)list.get(x);
if("world".equals(x)){
list.add("javaee");
}
}
System.out.println(list);//[hello, world, java, javaee]

List:(面试List的子类特点)
ArrayList：
底层数据结构是数组，查询块，增删慢。
线程不安全，效率高。
Vector：
底层数据是数组，查询快，增删慢。
线程安全，效率低。
LinkedList：
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

List有三个儿子，我们使用谁？
看需求。

安全性不好：
查询多用ArrayList
增删多用LinkedList