List接口
List接口的定义
List interface List extends Collection
通过观察List接口的定义发现其继承得是Collection接口
List、Set、Queue接口继承的都是Collection接口
Collection接口常用方法
1. public boolean add(E e); //添加元素到集合
2. public boolean addAll(Collection<? extends E> c); //存放一个集合
3. public boolean contains(Object o); //查找集合中的元素
4. public boolean isEmpty(); //判断一个集合是否为空
5. public boolean remove(Object 0);//删除一个集合中的元素
6. public int size();//返回集合的长度
List接口中的方法
List接口拓展了Collection接口中的方法
1. public E get(int index); //根据索引取得元素
2. public E set(int index,E element);//替换元素，index为要替换元素下标 element为要替换元素
3. public ListIterator<E> listIterator() List //List自己的迭代器
List 接口的特点是：可重读的，有序的
使用List list本身是一个接口，如果想要使用一个接口则可以使用该接口的实现类完成
重点实现类：ArrayList LinkedList Vector
package java8_7.Collection.List;
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo {
public static void main(String[] args) {
List<Integer> list =new ArrayList<>();
list.add(4);
list.add(5);
list.add(6);
list.add(4);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
运行结果为
4
5
6
4
可见，ArrayList 的特点是可重复的，有序的，顺序就是储存添加时候的数据
通过一个add 添加到集合，通过get(index)取出集合中的元素 下标的位置从0开始
其他的一些方法
package java8_7.Collection.List;
import java.util.ArrayList;
import java.util.List;
public class ListDemo2_function {
public static void main(String[] args) {
List<Integer> array = new ArrayList<>();
System.out.println("array是否为空："+array.isEmpty());
array.add(4);
array.add(5);
array.add(5);
System.out.println(array.remove(1));
array.add(1);
System.out.println(array.isEmpty());
System.out.println(array);
}
}
执行结果为
array链表是否为空：true
5
false
[4, 5, 1]
可见ArrayList是一个对象数组，每次增加的时候，会给数组扩容，数组长度是不能改变的，每次扩容数组内容拷贝工作，但是一个ArrayList如果频繁添加内容，效率不高。但是查询的时候由于底层是数组，所以查询效率很高。
并期添加数组都是从链表后方加，不会添加到链表中间位子
public class Person {
private String name;
private int age;
public Person(String name ,int age){
this.name=name;
this.age=age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "name:"+name+"age"+age;
}
@Override
public boolean equals(Object obj) { // 传进来要比较的内容
// TODO Auto-generated method stub
Person per=null;
if(obj instanceof Person) {
per=(Person)obj; // Object 向下转型 为 Person类型
}
// this 当前的对象 Person 和 传进来的Person比较
if(this==per) { //内存地址 一样肯定是同样对象
return true;
}
if(this.age==per.age&&this.name.equals(per.name)) {
return true;
}
return false;
}
}
重写Object中的equals方法 判断两个对象是否相同的语句为per=(Person)obj
若相同再比较this==per this里面有两个属性，即name age
写一个测试类
import java.util.ArrayList;
import java.util.List;
public class TestPerson {
public static void main(String[] args) {
List<Person> list = new ArrayList<>();
list.add(new Person("和尚",20));
list.add(new Person("jacky",30));
list.add(new Person("Sanny",40));
System.out.println(list.remove(new Person("Sanny",40)));
System.out.println(list.contains(new Person("和尚",20)));
for (Person per:list
) {
System.*out*.println(per);
}
}
}
结果：
true
true
name:和尚,age20
name:jacky,age30
通过代码，发现自定义类的时候，必须覆写equals()方法才能完成集合中对对象查找和删除，主要是在于进行对象删除的时候，集合中会判断传入的元素和集合本身是否是内容相同的元素，只有相同才会删除或者查找
LinkedList接口
这个子类是基于链表的体现 指针节点的形式 指针-节点->>
LinkedList也是可重复的有序的，顺序是储存顺序
以下为LinkedList类的定义
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,Cloneable,Serializable
接口定义：标准、能力、对外暴露方法
Cloneable 进行对象克隆的时候，必须实现接口，才有克隆的能力
Serializable：要实现序列化的类，必须实现接口才能能有序列化的的能力
特点： 插入方便，任意节点之间都可以插入，但是查询并不方便，效率不高
LinkedList的常用方法
1. public void addFirst(E e);
2. public void addList(E e);
import java.util.LinkedList;
public class LinkedListDemo1 {
public static void main(String[] args) {
LinkedList<String> list =new LinkedList<>() ;
list.add("hello");
list.add("world");
list.add("java");
list.addFirst("first");
list.addLast("last");
for (String str:list){
System.*out*.println(str);
}
}
}
经过对比，ArrayList和LinkedList有什么区别？
1. ArrayList 是基于数组开发的，查询效率很高，但是修改数据效率会低一些
2. LinkedList 是基于链表开发的，两端插入的时候效率很高，但是查询效率会低一些
