1.集合简介

Java集合可分为Set、List、Queue|和Map四种体系。

注：无序表示存储顺序与输入顺序不一致

不可重复表示：set集合能去重

JavaJava集合就像一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java 5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。

2.集合与数组的区别

List集合

一、ArrayList集合

1.ArrayList集合的特点

a.ArrayList是集合的一个实现类

b.ArrayList内部封装了一个Object类型（可以储存所有类型）的数组，初始长度10，且长度可变（数组扩容绝对不能在元地址上进行扩容，原因在于会影响其他程序的内存。扩容指的是放弃原地址空间，重新在空白内存处，开辟更大的内存空间）

c.ArrayList集合的查询快，但是增删慢（可以通过索引查询，增删要一个一个进行内容的覆盖）

2.ArrayList集合的一些方法

①.add(Object element) 向列表的尾部添加指定的元素。

②.size() 返回列表中的元素个数。

③.get(int index) 返回列表中指定位置的元素，index从0开始。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>(); //<String>泛型表示集合中存的是字符串形式的元素。
        list.add("熊大"); //add()用于向List集合容器中添加元素。
        list.add("熊二");
        System.out.println(list);
        System.out.println(list.size()); //size()用于获取集合中有多少个元素。
        System.out.println(list.get(1)); //get()获取指定索引（从0开始）位置的元素。
    }
}

运行结果

④.add(int index, Object element) 在列表的指定位置（从0开始）插入指定元素

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("xd");
        list.add("xe");
        System.out.println(list);
        list.add(1, "gtq"); //在指定位置添加元素，原来位置的元素后置。
        System.out.println(list);
    }
}

运行结果

⑤.set(int i, Object element) 使用元素element替换索引i位置的元素，并返回被替换的元素。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("xd");
        list.add("xe");
        System.out.println(list);
        list.set(1, "xd2"); //替换指定位置的元素，从0开始，替换了“xd”。
        System.out.println(list);
    }
}

运行结果

⑥.clear() 从列表中移除所有元素。

⑦.isEmpty() 判断列表是否包含元素，不包含元素则返回 true，否则返回false。

运行结果

⑧.contains(Object o) 如果列表包含指定的元素，则返回 true。

public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("xd");
            list.add("xe");
            boolean flag = list.contains("gtq"); //用来判断集合容器中是否含有参数元素。
            System.out.println(flag);
        }
}

运行结果：false

⑨.remove(int index) 移除列表中指定位置的元素，并返回被删元素，删除位置后面的元素（如果有）向前移动。

public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("熊大");
            list.add("熊二");
            list.add("光头强");
            System.out.println(list.remove(1)); //删除指定索引（从0开始）位置的元素，并将元素返回,并后面元素前移。
            System.out.println(list);
        }
}

运行结果

⑩.remove(Object o) 从List集合中移除第一次出现的指定元素，移除成功返回true，否则返回false。当且仅当List集合中含有满(o==null ? get(i)==null : o.equals(get(i)))条件的最低索引i的元素时才会返回true。

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("熊大");
        list.add("熊二");
        list.add("光头强");
        list.add("蹦蹦");
        System.out.println(list.remove("熊二")); //删除List集合元素，返回boolean,并后面元素前移。
        System.out.println(list);
    }
}

运行结果

11.iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。

public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("熊大");
            list.add("熊二");
            Iterator<String> ite = list.iterator(); //将List集合中元素转到iterator变量中。
            while(ite.hasNext()) //hasNext()判断当前“指针”下面是否还有元素的方法，java中没有指针，这只是举个例子。
            {
                System.out.println(ite.next()); //如果“指针”下面有元素，则移动“指针”并获取相应位置的元素。
            }
        }
}

运行结果

12.for循环遍历List集合

public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("熊大");
            list.add("熊二");
            for (int i = 0; i < list.size(); i++) {  //用size方法获取长度。
                System.out.println(list.get(i));  //用get方法获取值。
            }
        }
}

运行结果

13.加强for循环遍历List集合

public class ArrayListTest {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("熊大");
            list.add("熊二");
            for (String name : list) {   //使用foreach进行遍历。
                System.out.println(name);
            }
        }
}

运行结果

二、LinkedList集合

1.LinkedList集合的一些方法

①.添加

boolean add（Object element） 它将元素附加到列表的末尾。

boolean add（int index,Object element） 指定位置插入。 void addFirst(E element) 元素附加到列表的头部 void addLast(E element) 元素附加到列表的尾部

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.addFirst(4);
linkedList.addFirst(5);
linkedList.addLast(6);
linkedList.add(2,9);
System.out.println(linkedList);

运行结果

②：获取数据

Object get(int index) 根据下标获取数据

Object getFirst（） 它返回链表的第一个元素。

Object getLast（） 它返回链接列表的最后一个元素。

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("获取下标为1的元素："+linkedList.get(1));
System.out.println("链表的第一个元素："+linkedList.getFirst());
System.out.println("链表的最后一个元素："+linkedList.getLast());

运行结果

③.查询

boolean contains（Object element）如果元素存在于列表中，则返回true。

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
System.out.println("是否出现过元素1："+linkedList.contains(1));
System.out.println("是否出现过元素4:"+linkedList.contains(4));

运行结果

Object set（int index，Object element）它用于用新元素替换列表中的现有元素

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
linkedList.set(1,9);
System.out.println("更新过的链表："+linkedList);

输出

更新过的链表：[1, 9, 3, 1]

⑤.删除

remove() 删除第一个元素

 remove(int location) 删除指定位置的元素

 removeFirst() 删除并返回链接列表的头部一个元素

 removeLast() 删除并返回链接列表的尾部一个元素

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
linkedList.remove(); //删除第一个元素
linkedList.remove(2);//删除指定位置的元素
System.out.println(linkedList);

输出结果

6. 清空

void clear（）：它删除列表中的所有元素。

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
linkedList.clear();
System.out.println(linkedList);

输出:[]

7.链表长度

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
System.out.println("链表的长度："+linkedList.size());

链表的长度：4

三、Vector集合（不建议使用）

为范型数组

1. 创建 Vector

• 使用默认构造函数创建一个空的 Vector。

• 可以指定初始容量和容量增量。

  public static void main(String[] args) {
          // 创建一个空的 Vector
          Vector<String> vector = new Vector<>();
  
          // 创建具有初始容量的 Vector
          Vector<Integer> vectorWithCapacity = new Vector<>(10);
  
          // 创建具有初始容量和容量增量的 Vector
          Vector<Double> vectorWithIncrement = new Vector<>(10, 5);
      }

  2. 添加元素

• 使用 add() 方法添加元素。
• 使用 addElement() 方法添加元素（与 add() 类似，但专为 Vector 设计）。

  vector.add("Apple");
  vector.add("Banana");
  vector.addElement("Cherry"); // 与 add() 类似
  System.out.println(vector); // 输出: [Apple, Banana, Cherry]

  输出结果

     

   3. 访问元素

• 使用 get() 方法通过索引访问元素。
• 使用 elementAt() 方法通过索引访问元素（与 get() 类似，但专为 Vector 设计）。

  String fruit = vector.get(1); // 获取索引为 1 的元素
  System.out.println(fruit); // 输出: Banana
  
  String fruit2 = vector.elementAt(2); // 获取索引为 2 的元素
  System.out.println(fruit2); // 输出: Cherry

  4. 修改元素

• 使用 set() 方法修改指定索引处的元素。

  vector.set(1, "Blueberry"); // 将索引为 1 的元素修改为 Blueberry
  System.out.println(vector); // 输出: [Apple, Blueberry, Cherry]

  5. 删除元素

• 使用 remove() 方法删除指定索引或指定元素。
• 使用 removeElement() 方法删除指定元素（与 remove() 类似，但专为 Vector 设计）。
• 使用 clear() 方法清空所有元素。

  vector.remove(1); // 删除索引为 1 的元素
  System.out.println(vector); // 输出: [Apple, Cherry]
  
  vector.removeElement("Cherry"); // 删除元素 Cherry
  System.out.println(vector); // 输出: [Apple]
  
  vector.clear(); // 清空所有元素
  System.out.println(vector); // 输出: []

  6.获取大小和容量

• 使用 size() 方法获取当前元素数量。
• 使用 capacity() 方法获取当前容量。

  System.out.println("Size: " + vector.size()); // 输出: Size: 0
  System.out.println("Capacity: " + vector.capacity()); // 输出: Capacity: 10

  7.获取大小和容量

• 使用 for 循环遍历。
• 使用 Iterator 遍历。
• 使用 Enumeration 遍历（专为 Vector 设计）。

  // 使用 for 循环
  for (int i = 0; i < vector.size(); i++) {
      System.out.println(vector.get(i));
  }
  
  // 使用 Iterator
  Iterator<String> iterator = vector.iterator();
  while (iterator.hasNext()) {
      System.out.println(iterator.next());
  }
  
  // 使用 Enumeration
  Enumeration<String> enumeration = vector.elements();
  while (enumeration.hasMoreElements()) {
      System.out.println(enumeration.nextElement());
  }

  8. 检查元素是否存在

• 使用 contains() 方法检查是否包含指定元素。

  boolean containsApple = vector.contains("Apple");
  System.out.println(containsApple); // 输出: true

  9. 转换为数组

• 使用 toArray() 方法将 Vector 转换为数组。

  String[] array = vector.toArray(new String[0]);
  for (String s : array) {
      System.out.println(s);
  }

10. 其他常用方法

• isEmpty(): 检查 Vector 是否为空。
• indexOf(): 返回指定元素的索引。
• lastIndexOf(): 返回指定元素最后一次出现的索引。
• trimToSize(): 将容量调整为当前元素数量。

  boolean isEmpty = vector.isEmpty();
  System.out.println(isEmpty); // 输出: false
  
  int index = vector.indexOf("Apple");
  System.out.println(index); // 输出: 0
  
  vector.trimToSize(); // 调整容量为当前元素数量

  11. 线程安全性

• Vector 是线程安全的，所有方法都是同步的。
• 如果不需要线程安全，可以使用 ArrayList 替代。

  // 多线程环境下使用 Vector
  Vector<Integer> sharedVector = new Vector<>();
  
  Runnable task = () -> {
      for (int i = 0; i < 1000; i++) {
          sharedVector.add(i);
      }
  };
  
  Thread thread1 = new Thread(task);
  Thread thread2 = new Thread(task);
  thread1.start();
  thread2.start();

  四、List总结