1.List集合的概述和特点

LIst集合概述

  • 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
  • 与Set集合不同，列表通常允许重复的元素

List集合特点

  • 有序:存储和取出的元素顺序一致0
  • 可重复:存储的元素可以重复 
  1. package com.study_01;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. public class ListDemo01 {
  8.     public static void main(String[] args) {
  9.         // 创建集合对象  多态
  10.         List<String> list = new ArrayList<>();
  12.         // 添加元素:boolean add(E e)
  13.         list.add("hello");
  14.         list.add("world");
  15.         list.add("java");
  16.         list.add("hello");
  18.         // boolean hasNext():如果迭代具有更多元素，则返回true
  19.         Iterator<String> it = list.iterator();
  20.         while (it.hasNext()) {
  21.             // E next():返回迭代中的下一个元素
  22.             String s = it.next();
  23.             System.out.println(s);
  24.         }
  25.     }
  26. }

2.List集合的特有方法

方法名 说明
void add(String item, int index) 在此集合指定位置插入指定的元素
E remove(int index) 删除指定索引出的元素，返回别删除的元素
E set(Int index,E element) 修改指定索引出的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素 
  1. package com.study_01;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ListDemo02 {
  7.     public static void main(String[] args) {
  8.         List<String> list = new ArrayList<>();
  10.         // 添加元素:boolean add(E e)
  11.         list.add("hello");
  12.         list.add("world");
  13.         list.add("java");
  15.         // 在此集合指定位置插入指定的元素:void add(String item, int index)
  16. //        list.add(1,"javaEE");
  17. //        list.add(11,"javaEE"); // IndexOutOfBoundsException  索引越界异常
  19.         // 删除指定索引处的元素，返回别删除的元素:E remove(int index)
  20. //        System.out.println(list.remove(1)); // world
  21. //        System.out.println(list.remove(11)); // IndexOutOfBoundsException  索引越界异常
  23.         // 修改指定索引处的元素，返回被修改的元素:Eset(Int index,E element)
  24. //        System.out.println(list.set(1,"javaEE")); // world
  25. //        System.out.println(list.set(11,"javaEE")); // IndexOutOfBoundsException  索引越界异常
  27.         // 返回指定索引处的元素:E get(int index)
  28. //        System.out.println(list.get(1)); // world
  29. //        System.out.println(list.get(11)); // IndexOutOfBoundsException  索引越界异常
  31. //        System.out.println(list);
  33.         for (int i = 0; i < list.size(); i++) {
  34.             // E next():返回迭代中的下一个元素
  35.             String s = list.get(i);
  36.             System.out.println(s);
  37.         }
  38.     }
  39. }

3.并发修改异常

并发修改异常

ConcurrentModificationException

产生原因

迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致‘’

  1. package com.study_03;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. public class ListDemo {
  8.     public static void main(String[] args) {
  9.         List<String> list = new ArrayList<>();
  11.         // 添加元素:boolean add(E e)
  12.         list.add("hello");
  13.         list.add("world");
  14.         list.add("java");
  16.         // Iterator<E> iterator() 返回此集合中元素的迭代器 通过集合的iterator()方法得到
  17.         Iterator<String> it = list.iterator();
  18. //        while (it.hasNext()) {
  19. //            String s = it.next();
  20. //            if (s.equals("world")){
  21. //                list.add("javaee"); // ConcurrentModificationException 并发修改异常
  22. //            }
  23. //            System.out.println(s);
  24. //        }
  26.         // 通过for循环不会报异常
  27.         for (int i = 0; i < list.size(); i++) {
  28.             String s = list.get(i);
  29.             if (s.equals("world")){
  30.                 list.add("javaee");
  31.             }
  32.         }
  33.         System.out.println(list);
  34.     }
  35. }

4.ListIterator

Listlterator:列表迭代器

  • 通过List集合的listlterator()方法得到，所以说它是List集合特有的迭代器
  • 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中常用的方法

方法名 说明
E next() 返回迭代中的下一个元素
boolean hasNext() 如果迭代具有更多元素，则返回true
E previous() 返回列表中的上一个元素
boolean hasPrevious() 如果此列表迭代器在相反方向遍历列表时具有更多的元素，则返回true
void add(E e) 将指定的元素插入列表 
  1. package com.study_04;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.ListIterator;
  7. public class ListIteratorDemo {
  8.     public static void main(String[] args) {
  9.         // 创建一个集合对象
  10.         List<String> list = new ArrayList<>();
  12.         // 添加元素:boolean add(E e)
  13.         list.add("hello");
  14.         list.add("world");
  15.         list.add("java");
  17.         // 正向迭代
  18. //        ListIterator<String> lit = list.listIterator();
  19. //        while (lit.hasNext()){
  20. //            String s = lit.next();
  21. //            System.out.println(s);
  22. //        }
  23. //        System.out.println("--------------");
  24.         // 反向迭代  lit
  25. //        while (lit.hasPrevious()){
  26. //            String s = lit.previous();
  27. //            System.out.println(s);
  28. //        }
  30.         // 获取列表迭代器
  31.         ListIterator<String> lit = list.listIterator();
  32.         while (lit.hasNext()){
  33.             String s = lit.next();
  34.             // 在迭代期间修改列表，并获取列表中迭代器的当前位置
  35.             if (s.equals("world")) {
  36.                 lit.add("javase");
  37.             }
  38.         }
  39.         System.out.println(list);
  40.     }
  41. }

5.增强for循环

增强for:简化数组和Collection集合的遍历

  • 实现lterable接口的类允许其对象成为增强型for语句的目标
  • 它是JDK5之后出现的，其内部原理是一个lterator迭代器

增强for的格式
格式:

  1. for(元素数据类型 变量名:数组或者Collection集合){
  2.         //在此处使用变量即可，该变量就是元素
  3. }
  4. int[] arr = {1,2,3,4,5};
  5. for (int i :arr) {
  6.     System.out.println(i);
  7. }
  1. package com.study_05;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class ForDemo {
  7.     public static void main(String[] args) {
  8.         int[] arr = {1,2,3,4,5};
  9.         for (int i :arr) {
  10.             System.out.println(i);
  11.         }
  13.         List<String> list = new ArrayList<String>();
  14.         list.add("hello");
  15.         list.add("world");
  16.         list.add("java");
  18.         for (String i : list) {
  19.             System.out.println(i);
  20.         }
  22.         // 内部是个Iterator迭代器
  23.         for (String i : list) {
  24.             if(i.equals("world")) {
  25.                 list.add("javaee"); //ConcurrentModificationException 并发修改异常
  26.             }
  27.         }
  28.     }
  29. }

6.学生案例

三种for循环

7.常见数据结构之栈

栈是一种先进后出的模型

数据进入栈模型的过程称之为：压/进栈

数据离开栈模型的过程称之为：弹/出栈

8.常见数据结构之队列

队列是一种先进先出的模型

9.常见数据结构之数组

数组是一种查询快，增删慢的模型

查询速度快查询数据通过索引定位，查询任意数据耗时相同，查询效率高

删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低

添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

10.常见数据结构之链表

链表是一种增删快的模型(对比数组)

ps：因为链表每次查询都要从头开始查

链表是一种查询慢的模型(对比数组)

11.List集合子类特点

List集合的常用子类：ArrayList、LinkedList

  • ArrayList：底层数据结构是数组，查询快，增删慢
  • LinkedList：底层结构是双链表，查询慢，增删快

    12.LinkedList集合的特有功能

    | 方法名 | 说明 | | —- | —- | | public void addFirst(Ee) | 在该列表开头插入指定的元素 | | public void addLast(Ee) | 将指定的元素追加到此列表的末尾 | | public E getFirst() | 返回此列表中的第一个元素 | | public E getLast() | 返回此列表中的最后一个元素 | | public E removeFirst() | 从此列表中删除并返回第一个元素 | | public E removeLast() | 从此列表中删除并返回最后一个元素 |
  1. package com.study_09;
  3. import java.util.LinkedList;
  5. public class LinkedListDemo {
  6.     public static void main(String[] args) {
  7.         // 创建一个集合对象
  8.         LinkedList<String> linkedList = new LinkedList<>();
  10.         linkedList.add("hello");
  11.         linkedList.add("world");
  12.         linkedList.add("java");
  13.         // [hello, world, java]
  15.         // public void addFirst(Ee):在该列表开头插入指定的元素
  16.         // public void addLast(Ee):将指定的元素追加到此列表的末尾
  17. //        linkedList.addFirst("javaSe");
  18. //        linkedList.addLast("javase");
  20.         // publicE getFirst():返回此列表中的第一个元素
  21.         // public E getLast():返回此列表中的最后一个元素
  22. //        System.out.println(linkedList.getFirst());
  23. //        System.out.println(linkedList.getLast());
  25.         // public E removeFirst():从此列表中删除并返回第一个元素
  26.         // public E removeLast():| 从此列表中删除并返回最后一个元素 |
  28.         System.out.println(linkedList.removeFirst());
  29.         System.out.println(linkedList.removeLast());
  31.         System.out.println(linkedList);
  33.     }
  34. }