List集合(重中之重)

  • 基本概念

    java.util.List集合是Collection集合的子集合，元素有先后放入次序并且可以重复。

    该集合的主要实现类有：ArrayList类、LinkedList类、Stack类以及Vector类。

    其中ArrayList类的底层是采用数组进行数据管理的，访问方便但增删不方便。

    其中LinkedList类的底层是采用链表进行数据管理的，增删方便但访问不方便。

    其中Stack类的底层是采用数组进行数据管理的，该类主要用于描述具有后进先出特性的数据结构，叫做栈(last in first out 简称为：LIFO)。

    其中Vector类的底层是采用数组进行数据管理的，与ArrayList类相比属于早期提供的类，支持线程安全，但效率比较低，以后的开发中首选ArrayList类。

  • 常用的方法

    void add(int index,E element) - 向集合中指定位置添加元素.

    boolean addAll(int index, Collection<?extends E> c) - 向集合中添加所有元素.

    boolean remove(Object o) - 从集合中删除对象.

    E get(int index) - 从集合中获取指定位置元素.

    E set(int index,E element) - 修改指定位置的元素.

    E remove(int index) - 删除指定位置的元素.

    toArray() - 继承自Collection的方法，可以将集合中对象序列以对象数组的形式返回。

    1
    2
    3
    4
    5
    6
    List list = new ArrayList();
    list.add("one");
    list.add("two");
    list.add("three");
    String[] arry = (String[])list.toArray(new String[]{});
    System.out.println(Arrays.toString(arry));

    subList(int i,int j) - 截取集合的i到j（前包括，后不包括）为子集合
    此子集合与原集合占有相同的存储空间，对子集合的操作会影响到原集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.util.LinkedList;
import java.util.List;
public class ListTest {
  public static void main(String[] args) {
    // 1.声明List类型的引用指向实现类的对象
    List lt1 = new LinkedList();
    System.out.println("lt1 = " + lt1); // [啥也没有]

    // 2.向集合中添加元素并打印
    // 向下标为0的位置插入元素one  向开头位置插入元素
    lt1.add(0, "one");
    System.out.println("lt1 = " + lt1); // [one]
    // 向下标为1的位置插入元素3   向末尾位置插入元素
    lt1.add(1, 3);
    System.out.println("lt1 = " + lt1); // [one, 3]
    // 向下标为1的位置插入元素"two"，向中间位置插入元素
    lt1.add(1, "two");
    System.out.println("lt1 = " + lt1); // [one, two, 3]
    System.out.println("--------------------------------------");

    // 3.实现集合中元素的查找
    // 集合中之所以可以放入不同类型的对象，是因为这些对象都被看做Object
    // 类型放入的，那么取出来的元素类型也是Object类型
    String str1 = (String) lt1.get(0);
    System.out.println("获取到的元素是：" + str1); // one
    Integer it1 = (Integer) lt1.get(2);
    System.out.println("获取到的元素是：" + it1); // 3
    System.out.println("--------------------------------------");

    // 练习：使用get方法获取元素并拼接成toString方法的效果
    StringBuilder sb2 = new StringBuilder();
    sb2.append("[");
    for(int i = 0; i < lt1.size(); i++) {
      if(lt1.size()-1 == i) {
        sb2.append(lt1.get(i)).append("]");
      } else {
        // 将第一个字符串中的每个字符取出放入第二个字符串并跟随逗号
        sb2.append(lt1.get(i)).append(",").append(" ");
      }
    }
    System.out.println("lt1 = " + sb2);
    System.out.println("--------------------------------------");

    // 4.实现集合中元素的修改功能
    // [one, two, 3]
    Integer it2 = (Integer) lt1.set(2, "three");
    System.out.println("下标为2的旧元素是：" + it2); // 3
    System.out.println("lt1 = " + lt1); // [one, two, three]
    System.out.println("--------------------------------------");

    // 5.实现集合中元素的删除功能
    String str2 = (String) lt1.remove(1);
    System.out.println("被删除的元素是：" + str2); // two
    System.out.println("删除后集合中的元素有：" + lt1); // [one, three]
    System.out.println("--------------------------------------");

    // 练习：使用remove方法删除集合中的所有元素
    //for (int i = 0; i < lt1.size(); /* i++ */) {
    /*
    for (int i = lt1.size()-1; i >= 0; i--) {
      System.out.println("被删除的元素是：" + lt1.remove(i));
    }
    System.out.println("集合中最终的元素有：" + lt1);
    */
    System.out.println("--------------------------------------");

    // 6.获取List集合中的一部分内容，从下标0开始一直到下标1，但取不到1
    List lt2 = lt1.subList(0, 1);
    System.out.println("lt2 = " + lt2); // [one]
    lt2.set(0, 2);
    System.out.println("lt2 = " + lt2); // [2]
    System.out.println("lt1 = " + lt1); // [2, three]
  }
}

泛型机制(重点)

  • 基本概念

    通常情况下集合中可以存放不同类型的对象，是因为集合将这些对象全部看做Object类型放入的，当从集合中取出元素时也是Object类型的，为了表达该元素最真实的数据类型则需要进行强制类型转换，此时可能引发类型转换异常。

    为了避免上述错误的发生，从jdk1.5开始提出泛型机制，也就是在集合名称的右侧使用<数据类型>的方式明确要求该集合中可以存放元素的类型，若放入其他类型的元素则编译报错，如：

    List lt1 = new LinkedList();

  • 泛型的本质

    泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中集合中E作为形参负责占位，当使用集合时<>中的数据类型作为实参给E进行赋值操作，从而使得集合中所有的E都被替换为实参指定的类型。

    由于实参的传递支持各种各样广泛的类型，因此得名为"泛型机制".

    如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // 其中i表示形式参数，负责占位            其中E表示形式参数，负责占位
    // int i = 2;                             E = String;
    // int i = 5;                             E = Student;
    public void show(int i) {                 public class List<E> {
       ...                                        ...
    }                                         }

    // 其中2表示实际参数，用于给形参初始化    // 其中String表示实际参数
    show(2);                                  List<String> lt1 = ...;
    show(5);                                  List<Student> lt2 = ...;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.LinkedList;
import java.util.List;
import cn.itxdl.day15.Student;
public class ListTypeTest {
  public static void main(String[] args) {
    List<String> lt1 = new LinkedList<String>();
    lt1.add("one");  // ok
    //lt1.add(2);    // error
    System.out.println("lt1 = " + lt1); // [one]
    System.out.println("-----------------------------");

    String str1 = lt1.get(0);
    System.out.println("获取到的元素是：" + str1); // one
    System.out.println("-----------------------------");

    List<Integer> lt2 = new LinkedList<Integer>();
    lt2.add(1);
    Integer it1 = lt2.get(0);
    System.out.println("获取到的元素是：" + it1); // 1
    System.out.println("-----------------------------");

    //List<Student> lt3 = new LinkedList<Student>();
    List<Student> lt3 = new LinkedList<>(); // 菱形特性  jdk1.7开始
    lt3.add(new Student(1001, "zhangfei", 30));
    Student st1 = lt3.get(0);
    System.out.println("st1 = " + st1); // 1001 zhangfei ...
  }
}

Stack集合(栈，后进先出)

boolean push(E e) - 将一个对象添加至栈顶，若成功则返回true。

E pop() - 从栈顶删除并返回一个元素。

E peek() - 返回栈顶的元素（但并不删除）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Stack;
public class StackTest {
  public static void main(String[] args) {
    // 1.准备一个Stack类型的对象
    Stack<Integer> s = new Stack<Integer>();
    // 2.将数据11、22、33、44、55依次存入到栈中并打印
    for(int i = 1; i <= 5; i++) {
      s.push(i*11);
      System.out.println("栈中的元素有：" + s); // 11 22 33 44 55
    }
    System.out.println("-------------------------------");

    // 3.查看栈顶元素值并打印
    System.out.println("栈顶元素是：" + s.peek()); // 55
    System.out.println("-------------------------------");

    // 4.将栈中的所有元素依次出栈并打印
    int len = s.size();
    for(int i = 1; i <= len; i++) {
      System.out.println("出栈的元素是：" + s.pop());// 55 44 33 22 11
    }
    System.out.println("最终栈中的元素有：" + s); // 啥也没有
  }
}

Queue集合(重点)

  • 基本概念

    java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。

    该集合主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out，FIFO)。

    该集合的主要实现类有：LinkedList类，该类在增删方面有优势。

  • 常用的方法

    boolean offer(E e) - 将一个对象添加至队尾，若成功则返回true。

    E poll() - 从队首删除并返回一个元素。

    E peek() - 返回队首的元素（但并不删除）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.LinkedList;
import java.util.Queue;
public class QueueTest {
  public static void main(String[] args) {
    // 1.准备Queue类型的集合
    Queue<Integer> q1 = new LinkedList<Integer>();
    // 2.将数据11、22、33、44、55依次放入集合并打印
    for(int i = 1; i <= 5; i++) {
      boolean b1 = q1.offer(i*11);
      //System.out.println("b1 = " + b1);
      System.out.println("队列中的元素有：" + q1); // 11 22 33 44 55
    }
    System.out.println("-----------------------------");

    // 3.查看队列中队首元素值并打印
    System.out.println("队列中队首元素是：" + q1.peek()); // 11
    System.out.println("-----------------------------");

    // 4.将队列中的所有元素依次出队并打印
    int len = q1.size();
    for(int i = 1; i <= len; i++) {
      System.out.println("出队的元素是：" + q1.poll()); //11 22 33 44 55
    }
    // 5.打印队列中最终的所有元素
    System.out.println("队列中最终的元素有：" + q1); // 啥也没有
  }
}