帮助我们建立类型安全的集合

本质

数据类型的参数化
我们可以把 泛型 理解为数据类型的一个 占位符（形式参数） ，即告诉 编译器 在调用泛型时必须传入实际类型
image.png

Collection接口_List接口_ArrayList常用方法

image.png
add() 向容器中添加元素
size() 返回元素个数
contains() 判断元素是否存在
remove() 容器中存放的是地址，移除的时候是把 地址 删掉，但是对象还是存在
clear() 移除所有元素

  1. package sc.sxt.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  6. /**
  7.  * 测试Collection接口中的方法
  8.  * 
  9.  * @author DYQ
  10.  *
  11.  */
  12. public class TestList {
  13.     public static void main(String[] args) {
  14.         Collection c = new ArrayList<>();
  15.         System.out.println(c.size()); // 0
  16.         System.out.println(c.isEmpty()); // true
  18.         //add()向容器中添加元素
  19.         c.add("高老大");
  20.         c.add("高老二");
  21.         System.out.println(c); // [高老大, 高老二]
  22.         //size() 返回元素个数
  23.         System.out.println(c.size()); // 2
  25.         //contains() 判断元素是否存在
  26.         System.out.println(c.contains("高老大"));// true
  27.         System.out.println(c.contains("高老五"));// false
  30.         Object[] objs = c.toArray();
  31.         System.out.println(objs); // [Ljava.lang.Object;@4c203ea1
  33.         c.remove("高老二"); //// 容器中存放的是地址，移除的时候是把地址删掉，但是对象还是存在
  34.         System.out.println(c); // [高老大]
  36.         c.clear(); // 移除所有元素
  37.         System.out.println(c); // []
  39.     }
  40. }

操作多个List_并集和交集（多个容器操作

addAll() 将另一个集合中所有元素都加进来
removeAll() 删除两个集合相同的部分
retainAll() 取交集
list01.containsAll(list02) 1的集合是否包含2集合中所有的元素

  1. package sc.sxt.collection;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class TestList01 {
  7.     public static void main(String[] args) {
  8.         text02();
  9.     }
  11.     public static void text02() {
  12.         List<String> list01 = new ArrayList<>();
  13.         //Collection <String> list01 = new ArrayList<>();
  15.         list01.add("aa");
  16.         list01.add("bb");
  17.         list01.add("cc");
  19.         List<String> list02 = new ArrayList<>();
  20.         list02.add("aa");
  21.         list02.add("dd");
  22.         list02.add("ee");
  24.         System.out.println("list01:" + list01);// list01:[aa, bb, cc]
  26.         // addAll()将另一个集合中所有元素都加进来
  27. //        list01.addAll(list02);
  28. //        System.out.println("list01.addAll:" + list01);
  29.         // list01:[aa, bb, cc, aa, dd, ee]
  31.         // removeAll()删除两个集合相同的部分
  32. //        list01.removeAll(list02);
  33. //        System.out.println("list01.removeAll:" + list01);
  34.         // list01.removeAll:[bb, cc]
  36.         // 取交集
  37. //        list01.retainAll(list02);
  38. //        System.out.println("list01.retainAll:" + list01);  //list01.retainAll:[aa]
  40.         // list01.containsAll(list02) 1的集合是否包含2集合中所有的元素
  41.         System.out.println(list01.containsAll(list02)); //false 
  44.     }
  45. }

List list01 = new ArrayList<>();
//Collection list01 = new ArrayList<>();
List可以换成Collection

索引和顺序相关方法

List 是有序、可重复的容器
有序 ：List每个元素都有索引标记，可以根据元素的索引标记（在List中的位置）访问元素，从而精确控制这些元素
可重复 ：List允许加入重复的元素。更确切的讲，List通常允许满足e1.equals(e2)的元素重复加入容器

List接口的实现类有三个：ArrayList、LinkedList、Vector

add(int index , E e) 在索引位置处添加一个新的元素
remove(int index) 将某个位置的元素删除
set(int index , E e) 将某个位置的元素替换（修改）成另一个元素
get(int index) 返回某个位置的元素

indexOf(E e) 返回第一个符合的元素的位置
lastIndexOf(E e) 返回最后一个符合的元素的位置

  1. package sc.sxt.collection;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class TestList01 {
  7.     public static void main(String[] args) {
  8.         text03();
  9.     }
  11.     public static void text03() {
  12.         List<String> list = new ArrayList<String>();
  13.         list.add("A");
  14.         list.add("B");
  15.         list.add("C");
  16.         list.add("D");
  18.         System.out.println(list);// [A, B, C, D]
  20.         // 在索引位置处添加一个新的元素
  21.         list.add(2, "dyq");
  22.         System.out.println(list);// [A, B, dyq, C, D]
  24.         // 将某个位置的元素删除
  25.         list.remove(2);
  26.         System.out.println(list);// [A, B, C, D]
  28.         // 将某个位置的元素替换（修改）成另一个元素
  29.         list.set(2, "高老二");
  30.         System.out.println(list); // [A, B, 高老二, D]
  32.         // 返回某个位置的元素
  33.         System.out.println(list.get(2)); // 高老二
  35.         list.add("C");
  36.         list.add("B");
  37.         list.add("A");
  38.         System.out.println(list); // [A, B, 高老二, D, C, B, A]
  40.         // 返回第一个符合的元素的位置
  41.         System.out.println(list.indexOf("B")); // 1
  42.         //返回最后一个符合的元素的位置
  43.         System.out.println(list.lastIndexOf("B")); //5
  44.     }
  45. }

Collections工具类

和Collection接口是两码事C
Collections.shuffle(list); // 随机排列list中的元素
Collections.reverse(list); // 逆序排序
Collections.sort(list); // 按照递增方式排序。
Collections.binarySearch(list, “张三”); 二分法查找是否有某个元素，没找到就返回一个负的索引值

  1. package sc.sxt.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. /**
  8.  * Collections辅助类使用
  9.  * 
  10.  * @author DYQ
  11.  *
  12.  */
  13. public class TestCollections {
  14.     public static void main(String[] args) {
  15.         List<String> list = new ArrayList<String>();
  16.         for (int i = 0; i < 10; i++) {
  17.             list.add("gao:" + i);
  18.         }
  19.         System.out.println(list);
  21.         Collections.shuffle(list); // 随机排列list中的元素
  22.         System.out.println(list);
  24.         Collections.reverse(list); // 逆序排序
  25.         System.out.println(list);
  27.         Collections.sort(list); // 按照递增方式排序。
  28.         System.out.println(list);
  30.         // 二分法查找是否有某个元素
  31.         System.out.println(Collections.binarySearch(list, "张三")); // -11
  32.         // 没找到就返回一个负的索引值
  33.         System.out.println(Collections.binarySearch(list, "gao:1")); //1
  34.     }
  35. }
  38. [gao:0, gao:1, gao:2, gao:3, gao:4, gao:5, gao:6, gao:7, gao:8, gao:9]
  39. [gao:0, gao:1, gao:6, gao:3, gao:9, gao:4, gao:8, gao:2, gao:7, gao:5]
  40. [gao:5, gao:7, gao:2, gao:8, gao:4, gao:9, gao:3, gao:6, gao:1, gao:0]
  41. [gao:0, gao:1, gao:2, gao:3, gao:4, gao:5, gao:6, gao:7, gao:8, gao:9]
  42. -11
  43. 1