List集合
List集合是一个有序且元素可以重复的集合，List是一个接口，直接父接口是Collection
其中常用的接口有：ArrayList和LinkedList接口
ArrayList与LinkedList的区别：
相同点：两者都是List接口的实现类，提供的API的功能逻辑是一样的
不同点：两者的底层实现原理不同，ArrayList底层是基于数组实现的，
而LinkedList是基于线性链表实现的，前者查找快，增删慢；后者查找慢，增删快
List接口的接口方法
boolean add(E e)
将指定的元素到这个列表的末尾（可选操作）。
void add(int index, E element)
在列表中指定的位置上插入指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
追加指定集合的所有元素到这个列表的末尾，按他们的指定集合的迭代器返回（可选操作）。
boolean addAll(int index, Collection<? extends E> c)
将指定的集合中的所有元素插入到指定位置的列表中（可选操作）。
void clear()
从这个列表中移除所有的元素（可选操作）。
boolean contains(Object o)
返回 true如果这个列表包含指定元素。
boolean containsAll(Collection<?> c)
返回 true如果这个列表包含指定集合的所有元素。
boolean equals(Object o)
将指定的对象与此列表进行比较，以进行相等性。
E get(int index)
返回此列表中指定位置的元素。
int hashCode()
返回此列表的哈希代码值。
int indexOf(Object o)
返回此列表中指定元素的第一个出现的索引，或-如果此列表不包含元素，或- 1。
boolean isEmpty()
返回 true如果此列表不包含元素。
Iterator<E> iterator()
在这个列表中的元素上返回一个正确的顺序。
int lastIndexOf(Object o)
返回此列表中指定元素的最后一个发生的索引，或-如果此列表不包含元素，或- 1。
ListIterator<E> listIterator()
返回列表元素的列表迭代器（在适当的顺序）。
ListIterator<E> listIterator(int index)
在列表中的元素上返回列表迭代器（在适当的顺序），从列表中的指定位置开始。
E remove(int index)
移除此列表中指定位置的元素（可选操作）。
boolean remove(Object o)
从该列表中移除指定元素的第一个发生，如果它是存在的（可选操作）。
boolean removeAll(Collection<?> c)
从这个列表中移除包含在指定集合中的所有元素（可选操作）。
default void replaceAll(UnaryOperator<E> operator)
用将运算符应用到该元素的结果替换此列表中的每个元素。
boolean retainAll(Collection<?> c)
仅保留包含在指定集合中的列表中的元素（可选操作）。
E set(int index, E element)
用指定元素替换此列表中指定位置的元素（可选操作）。
int size()
返回此列表中元素的数目。
default void sort(Comparator<? super E> c)
分类列表使用提供的 Comparator比较元素。
default Spliterator<E> spliterator()
创建此列表中的元素的 Spliterator。
List<E> subList(int fromIndex, int toIndex)
返回一个视图之间的指定 fromIndex，包容，和 toIndex这份名单的部分，独家。
Object[] toArray()
返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一个到最后一个元素）。
<T> T[] toArray(T[] a)
返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一到最后一个元素）；返回数组的运行时类型是指定的数组的运行时类型。
package com.tedu.cn.collections;
import com.tedu.cn.collections.entity.Student;
import org.junit.Test;
import java.util.*;
public class Demo3 {
@Test
public void m1() {
List list = new ArrayList();
/**
* 向List集合中添加元素
* List集合是一个有序（添加的顺序就是元素在集合里面的顺序），元素可以重复的集合
* 所以List集合是一个有序且可重复集
*/
list.add(1);
list.add(5);
list.add(5);
list.add(7);
for (Object o : list) {
System.out.println(o);
}
}
@Test
public void m2() {
List list = new LinkedList();
list.add(5);
list.add(5);
list.add(21);
list.add(9);
for (Object o : list) {
System.out.println(o);
}
}
/**
* 由于ArrayList集合是基于数组实现的，那么可以通过下标的形式去访问ArrayList集合里面的元素
* List提供了一个get（int index）获取对应元素
*/
@Test
public void m3() {
List list = new ArrayList();
list.add(5);
list.add(8);
list.add(6);
list.add(0);
/**
* 根据下标访问集合里的元素
*/
System.out.println(list.get(0));
/**
* 根据下标修改元素
* List提供了一个API叫get（int index，Object，object）
*/
list.set(0, "hello");
System.out.println(list.get(0));
}
/**
* 指定位置添加元素add(int index,Object element)
* 删除指定位置元素remove(int index)
*/
@Test
public void m4() {
List list = new ArrayList();
list.add(5);
list.add(8);
list.add(9);
list.add(0);
list.add(2, "hello");
for (Object o : list) {
System.out.println(o);
}
list.remove(2);
}
/**
* 遍历list集合
* 既然List集合是基于数组的原理实现（动态数组）
* 那么可以使用for循环遍历集合
* 遍历集合的方法
* 使用新循环
* for循环
* 迭代器
* Java8提供的lamada表达式的相关接口遍历集合
*/
@Test
public void m5() {
List list = new ArrayList();
list.add(5);
list.add(8);
list.add(0);
System.out.println("------第一种方式：新循环------");
for (Object o : list) {
System.out.println(o);
}
System.out.println("------第二种方式：for循环------");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
/**
* 在使用迭代器遍历元素时，不要用集合删除集合里的元素
* 否则会出现异常
* 一定要使用迭代器去删除
*/
System.out.println("------第三种方式：迭代器循环------");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println("当前遍历的元素：" + iterator.next());
}
// System.out.println("------错误删除方法----");
// while(iterator.hasNext()){
// Object o=iterator.next();
// System.out.println("当前遍历的元素："+o);
// list.remove(o);
// }
// System.out.println("------正确删除方法----");
// while(iterator.hasNext()){
// Object o=iterator.next();
// System.out.println("当前遍历的元素："+o);
// iterator.remove();
// }
// System.out.println(list.size());
System.out.println("------第四种方式：1.8d的forEach API函数式接口------");
list.forEach(t -> System.out.println("当前迭代元素：" + t));
}
/**
* Java语言的泛型机制，所谓泛型就是让编译器能够在编译的时候识别出的类型
*/
public void m6() {
List<String> ls = new ArrayList<>();
ls.add("hello");
ls.add("world");
}
/**
* 泛型的使用场景：(大量用于集合中)
* 1、在接口上使用泛型
* 2、在类上使用泛型
* 3、在方法上使用泛型
* 4、方法的参数上使用泛型
*/
@Test
public void m7() {
// Computer<Integer> computer=new Computer<>();
// computer.cal(4,5);
Point<Integer> p = new Point<>(8, 8);
p.getPoint();
Point.m1("hello");
}
@Test
public void m8() {
Set<Student> ss = new HashSet<>();
Student s1 = new Student();
Student s2 = new Student();
ss.add(s1);
ss.add(s2);
System.out.println(ss.size());
}
/**
* 小测试：
* 创建一个List集合 规定这个集合只能存储Integer类型的类型，实现对这个集合的遍历
*/
@Test
public void m9() {
List<Integer> list = new ArrayList<>();
list.add(5);
list.add(10);
list.add(5);
list.add(3);
for (Object o : list) {
System.out.println(o);
}
System.out.println("-----------------------------------------");
list.forEach(t -> System.out.println("当前遍历的元素是：" + t));
Iterator iterator = list.iterator();
System.out.println("-----------------------------------");
while (iterator.hasNext()) {
System.out.println("当前遍历的元素是：" + iterator.next());
}
}
/**
* 泛型通配符
* ？
* ？extends T
* ？super T
*/
public void m10() {
List<?> ls = new ArrayList<>();
/**
* ？代表任何一种类型
* 使用泛型通配符？的时候不能使用add方法添加元素
* 原因是？的类型不能确定，因此不能添加
* 但是可以将另一个集合的引用对象赋值给它
*/
List<Integer> ls01 = new ArrayList<>();
ls01.add(1);
ls01.add(2);
ls01.add(3);
ls = ls01;//可以这样操作，因为ls01里面的元素的类型完全可以确定
}
/**
* 测试泛型上限 ？ extends T
* ?表示元素的类型必须是T的子类或者是T的类型本身
*/
@Test
public void m11() {
List<? extends A> ls = new ArrayList<>();
B b = new B();
/**
* ls.add(b)错误
* 由于？的类型无法确定，所以不能进行add操作
* 可以将一个已经确定了的类型的集合引用赋值给ls集合
*/
List<B> bs = new ArrayList<>();
bs.add(b);
ls = bs;
System.out.println(ls.size());
}
/**
* 测试泛型下限
* ? super T
* 表示？必须是T的父类类型或者是T类类型
*/
@Test
public void m12() {
List<? super B> ls = new ArrayList<>();
B b = new B();
D d = new D();
ls.add(d);
ls.add(b);//不能添加父类的类型，只能添加子类或者本类类型，原因是子类类型完全可以确定
System.out.println(ls.size());
// A a=new A();
// List<A> as=new ArrayList<>();
// as.add(a);
// ls=as;
// System.out.println(ls[0]);
/**
* 如果要添加元素建议使用？ super T的形式
* 如果要把一个集合的对象引用赋值为另一个集合，建议使用？extends T的形式
*/
}
@Test
public void m13() {
List<? extends B> lb = new ArrayList<>();
B b = new B();
D d = new D();
List<B> list = new ArrayList<>();
list.add(b);
list.add(d);
lb = list;
System.out.println();
}
@Test
public void m14() {
List<? super B> lb = new ArrayList<>();
B b = new B();
List<B> list = new ArrayList<>();
list.add(b);
lb = list;
System.out.println(lb.size());
}
}
556
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
