java.集合（Ⅱ）.List

1.List

意义：实现了Collection的子接口之一

特点：元素是有序的，是可重复的，因为该集合体系有索引。

常见三子类

|——ArrayList:底层用的数据结构用的是数组结构。

特点：查询速度很快，但增删稍慢，线程不同步，长度可变—默认长度为10，当超过已有长度时，自动生成延长百分之50数组，并自动转移数据。

|——LinkedList：底层使用的是链表数据结构。

特点：增删速度很快，查询速度慢

|——Vector：1.2版本前使用，和ArrayList功能一致。

特点：线程同步。操作速度很慢，一般不用。枚举是Vector的特有取出方法

因为枚举和迭代是一样的。且枚举的名称以及方法名称都过长。所以在1.5版本后被迭代器取代了。

List基本方法





List特有方法



几个知识点：

⑴当按角标进行添加方法时，操作相当于插入。相应角标的元素将后移。

⑵角标是从0开始的

⑶List类有特有的输出所有元素的方法，即用f.size()与f.get()进行遍历

for(int i=0;i<f.size();i++)
write(f.get(i));//write是一个自定义静态输出方法，就不另外加进来了

2.ListIterator

意义：List集合特有的迭代器。ListIterator是Iterator的子接口。

在迭代时，不可以在 通过集合对象的方法操作集合中的元素 的同时，又通过迭代器对元素进行操作。

因为会发生并发修改异常。

所以在操作中，只能通过一种途径的方法操作元素。而迭代器的方法只有

判断、取出、删除三种，即



因为其方法过少不能满足很多需求，所以List中就有了其子接口。ListIterator。其方法有：



该接口只能通过List集合的listIterator方法获取。

3.LinkedList

特有方法：





ex:

import java.util.LinkedList;

public class ListDemo {
public static void main(String[] args)
{
LinkedList f = new LinkedList();

f.offerFirst("java 01");
f.offerFirst("java 02");
f.offerFirst("java 03");
write(f);
}
public static void write(Object obj)
{
System.out.println(obj);
}
}

输出：



List的两个小练习：

去掉ArrayList中的重复元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class ListDemo {
public static void main(String[] args)
{
ArrayList f = new ArrayList();
f.add("java 01");
f.add("java 02");
f.add("java 02");
f.add("java 01");
f.add("java 03");
f.add("java 01");
write(f);
write("_________");
write(single(f));
}

public static ArrayList single(ArrayList f)
{
ArrayList f1 = new ArrayList();

for(Iterator it=f.iterator();it.hasNext();)
{
Object obj = it.next();

if(!f1.contains(obj))
{
f1.add(obj);
}
}
return f1;
}
public static void write(Object obj)
{
System.out.println(obj);
}
}

——————————————————

在ArrayList中输入学生信息，并排除重复的数据

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public boolean equals(Object obj)//contains用来判断对象是否相同，但它的底层自动调用的是默认方法equals，
//但当默认equals不能满足需求时，需要进行方法覆盖
{
Person p = (Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
public void setName(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
public class ListDemo {
public static void main(String[] args)
{
ArrayList f = new ArrayList();
f.add(new Person("java 01",1));
f.add(new Person("java 02",2));
f.add(new Person("java 02",1));
f.add(new Person("java 03",1));
f.add(new Person("java 04",1));
f.add(new Person("java 01",1));
Iterator it = single(f).iterator();
while(it.hasNext())
{
Person p =(Person)it.next();
write(p.getName()+"....."+p.getAge());
}

}

public static ArrayList single(ArrayList f)
{
ArrayList f1 = new ArrayList();

for(Iterator it=f.iterator();it.hasNext();)
{
Object obj = it.next();

if(!f1.contains(obj))//底层原理是equals
{
f1.add(obj);
}
}
return f1;
}
public static void write(Object obj)
{
System.out.println(obj);
}
}

一个知识点：

List中，contains和remove进行的比较，底层都是调用Object类中默认的equals方法，而当默认方法不能满足时，可以以覆盖equals方法的形式进行修改，就像第二个小练习中这样