7.29笔记

一、set List

set:无序的，不可重复，不能根据索引操作

List:有序的，可重复，可以根据索引操作

有序：存储的顺序与内部真实存放的顺序保持一致

新增方法：新增了一些与索引相关的方法

jdk1.7之前：标准写法 前后的类型都需要<String>

ArrayList<String> list = new ArrayList<String>();

jdk1.7之后：后面的类型后可以省略传递类型<>

ArrayList<String> list = new ArrayList<String>();

1.void add(int index, E element)
在此列表中的指定位置插入指定元素（可选操作）。
list.add(5,"aaaa");

2.boolean add(E e)
将指定元素附加到此列表的末尾（可选操作）。
list.add("ccc");

3.boolean addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
list.addAll(3,list1);

4.boolean addAll(Collection<? extends E> c)
将指定集合中的所有元素附加到此列表的末尾，按照指定集合的迭代器返回的顺序（可选操作）
list.addAll(list1);

5.int indexOf(Object o)
返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -1。
System.*out*.println(list.indexOf("aaa"));
​
int lastIndexOf(Object o)
返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回 -1。
System.*out*.println(list.lastIndexOf("aaa"));

6.E remove(int index)
移除此列表中指定位置的元素（可选操作）。
System.*out*.println(list.remove(2));
boolean remove(Object o)
如果指定元素存在，则从该列表中删除第一次出现的指定元素（可选操作）。
System.*out*.println(list.remove("abc"));

7.E set(int index, E element)
将此列表中指定位置的元素替换为指定元素（可选操作）。
System.*out*.println(list.set(2,"xxx"));

8.List<E> subList(int fromIndex, int toIndex)
返回此列表在指定fromIndex （包括）和toIndex （不包括）之间部分的视图。
List<String> ls=list.subList(3,6);

二、ListIterator

列表迭代器：ListIterator List独有的

列表的迭代器，允许程序员在任一方向遍历列表，在迭代期间修改列表，并获取迭代器在列表中的当前位置。

1.获取列表迭代器实例

2.判断是否存在下一个元素|判断是否存在上一个元素

3.获取下一个元素|获取索引|获取上一个元素以及索引

list集合遍历方式：

1.for

for(int i=0;i< list.size();i++){
    if("灭霸".equals(list.get(i))){
        list.add("惊奇队长!!!");
    }
}

2.foreach

for(String str:list){  //java.util.ConcurrentModificationException   if("灭霸".equals(str)){
        list.add("惊奇队长!!!");
    }
}

3.iterator

Iterator<String> it = list.iterator();  //java.util.ConcurrentModificationException
while(it.hasNext()){
    if("灭霸".equals(it.next())){
        list.add("惊奇队长!!!");
    }
}

4.listIterator

ListIterator<String> it2 =  list.listIterator();
while(it2.hasNext()){
    *//System.out.println(it2.nextIndex()+"--->"+it2.next());*    if("灭霸".equals(it2.next())){
        it2.add("惊奇队长!!!");
    }
}
System.*out*.println(list);
​
while(it2.hasPrevious()){
            System.out.println(it2.previousIndex()+"--->"+it2.previous());
        }
​
        System.out.println("-------------------------------");
​
        ListIterator<String> it3 = list.listIterator(3);//从前往后会遍历3
        while(it3.hasNext()){
            System.out.println(it3.nextIndex()+"--->"+it3.next());
        }
        System.out.println("-------------------------------");
        ListIterator<String> it4= list.listIterator(3);//向前不包含3
        while(it4.hasPrevious()){
            System.out.println(it4.previousIndex()+"--->"+it4.previous());
        }

注意：

java.util.ConcurrentModificationException 当这种修改是不允许的时，检测到对象的并发修改的方法可能

会抛出此异常。 例如，通常不允许一个线程在另一个线程对其进行迭代时修改Collection。

三、List接口下的实现类：

有序的，可重复的，可以根据索引操作的

ArrayList：***

允许所有元素，包括null

1.底层结构：

数组 Object[] elementData;

2.特点

根据索引查询效率高，做增删效率低

3.应用场景

适合应用在大量做查询，少量做增删的情况下

4.初始容量

默认为10 private static final int DEFAULT_CAPACITY = 10; | 可以通过构造器指定

5.扩容机制

每次扩容原容量的 1.5倍 int newCapacity = oldCapacity + oldCapacity>>1;

通过调用Arrays.copyOf方法实现扩容+拷贝数据

6.新增方法

没有新增方法

7.遍历方式

1)for

2)foreach

3)iterator

4)listIterator

请注意，此实现不同步。

Vector :向量 了解

共性 :

1)都是List接口下的实现类，相同的特点

2)底层结构都是数组,特点相同

不同点 :

1)线程安全问题

ArrayList : 线程不安全|不同步的

Vector : 线程安全|同步的

如果不需要线程安全实现，建议使用ArrayList代替Vector 。

2)初始容量与扩容机制

初始容量 :

ArrayList与Vector : 默认底层数组容量的为10 | 可以通过构造器指定

扩容机制 :

ArrayList : 每次扩容原容量的1.5倍

Vector : 如果用户指定每次扩容的容量增量capacityIncrement,就每次原容量+capacityIncrement,

如果用户没有指定capacityIncrement,那么每次扩容原容量的2倍

int dCapacity = oldCapacity + capacityIncrement > 0 ? capacityIncrement : oldCapacity?

注意 : 当使用ArrayList存储自定义引用数据类型的对象数据的时候，要求根据所有属性值重写toString与

equals

四、LinkedList

有序的，可重复的，可以根据索引操作的

允许所有元素，包括null

1.底层结构：

双向链表

2.特点：

查询效率低，增删效率高

3.应用场景：

大量做增删少量做查询的情况

4.新增方法

新增了一些操作链表头尾的方法

5.遍历方式：

1)for

2)foreach

3)iterator

4)listIterator

5)descendingIterator() 逆序迭代

请注意，此实现不同步

五、LinkedList

1.LinkedList() 构造一个空列表

LinkedList<Double>  list=new LinkedList<>()；

2.void addFirst(E e)    在此列表的开头插入指定元素
list.addFirst(3.5);
System.out.println(list);

3.void addLast(E e)     将指定元素附加到此列表的末尾。
list.addLast(5.3);
System.out.println(list);

4.boolean offerFirst(E e)       在此列表的前面插入指定的元素。list.offerFirst(3.4);
System.out.println(list);

5.boolean offerLast(E e)        在此列表的末尾插入指定的元素。list.offerLast(8.1);
System.out.println(list);

6.E getFirst()      返回此列表中的第一个元素。System.out.println(list.getFirst());

7.E getLast()       返回此列表中的最后一个元素。System.out.println(list.getLast());

7.E peekFirst()     检索但不删除此列表的第一个元素，如果此列表为空，则返回null。System.out.println(list.peekFirst());

8.E peekLast()      检索但不删除此列表的最后一个元素，如果此列表为空，则返回null
System.out.println(list.pollLast());

9.E pollFirst()     检索并删除此列表的第一个元素，如果此列表为空，则返回null
System.out.println(list.pollFirst());

10.E pollLast()     检索并删除此列表的最后一个元素，如果此列表为空，则返回null
System.out.println(list.pollLast());

11.E removeFirst()  从此列表中删除并返回第一个元素。
System.out.println(list.removeFirst());

12.boolean removeFirstOccurrence(Object o)  删除此列表中第一次出现的指定元素（从头到尾遍历列表时）。
System.out.println(list.removeFirstOccurrence(2.5));

13.E removeLast()   移除并返回此列表中的最后一个元素。System.out.println(list.removeLast());

14.boolean removeLastOccurrence(Object o)   删除此列表中指定元素的最后一次出现（从头到尾遍历列表时）。
System.out.println(list.removeLastOccurrence(2.5));
System.out.println(list);

15.逆序迭代descendingIterator()
Iterator<Double> it= list.descendingIterator();
while (it.hasNext()){
    System.out.println(it.next());
}