java list = list_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

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

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