java 集合

Java集合框架（Java Collections Framework）是一个强大的工具库，旨在简化数据存储和操作的任务。它提供了一组接口、类和算法，帮助开发者高效地管理数据，如列表、集合和映射。下面是Java集合框架的详细介绍：

一. 集合框架的核心接口

Java集合框架由多个核心接口组成，每个接口定义了不同的功能：

(1) Collection接口

Collection是所有集合类的根接口，定义了集合中元素的基本操作方法。主要方法包括：

• add(E e)：向集合添加元素。
• remove(Object o)：从集合中删除指定元素。
• clear()：清空集合。
• size()：返回集合中的元素个数。

(2) List接口

List接口继承自Collection接口，表示一个有序的元素集合。List中的元素可以重复，常见的实现类有：

• ArrayList：基于动态数组实现，适合快速随机访问。
• LinkedList：基于双向链表实现，适合频繁插入和删除。
• Vector：类似于ArrayList，但线程安全。

(3) Set接口

Set接口继承自Collection接口，表示一个不包含重复元素的集合。常见实现类有：

• HashSet：基于哈希表实现，元素无序。
• LinkedHashSet：基于哈希表和链表实现，保持插入顺序。
• TreeSet：基于红黑树实现，元素按升序排列。

(4) Queue接口

Queue接口表示一个队列集合，通常用于存储按顺序处理的元素。常见实现类有：

• PriorityQueue：基于堆实现的优先队列，元素按优先级排序。
• LinkedList：实现了Queue接口，适合队列操作。

(5) Map接口

Map接口表示一个键值对映射，存储键和值的关系。Map不继承自Collection接口。常见实现类有：

• HashMap：基于哈希表实现，不保证顺序。
• LinkedHashMap：基于哈希表和链表实现，保持插入顺序。
• TreeMap：基于红黑树实现，键按自然顺序或自定义排序。

6. 集合框架的实现类

Java集合框架提供了许多实现类，帮助开发者根据需求选择最合适的集合类型。常见的实现类有：

• ArrayList：动态数组实现，适合随机访问。
• LinkedList：双向链表实现，适合频繁插入和删除操作。
• HashSet：哈希表实现，元素无序，查找和插入效率高。
• TreeSet：红黑树实现，元素按顺序排列，支持范围查询。
• HashMap：哈希表实现，存储键值对，键唯一。
• TreeMap：红黑树实现，键有序，适合范围查找。

二 Collection集合

2.1数组和集合的区别

• 相同点

  都是容器,可以存储多个数据

• 不同点

  • 数组的长度是不可变的,集合的长度是可变的

  • 数组可以存基本数据类型和引用数据类型

    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

2.2 Collection 集合概述和使用

• Collection集合概述

  • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

• 创建Collection集合的对象

  • 多态的方式
  • 具体的实现类ArrayList

Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

2.3 Collection集合的遍历

2.3.1 迭代器遍历

• 迭代器介绍

  • 迭代器,集合的专用遍历方式
  • Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

• Iterator中的常用方法

  ​ boolean hasNext(): 判断当前位置是否有元素可以被取出
  ​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历

  public class IteratorDemo1 {public static void main(String[] args) {//创建集合对象Collection<String> c = new ArrayList<>();//添加元素c.add("hello");c.add("world");c.add("java");c.add("javaee");//Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到Iterator<String> it = c.iterator();//用while循环改进元素的判断和获取while (it.hasNext()) {String s = it.next();System.out.println(s);}}
  }
  

• 迭代器中删除的方法

  ​ void remove(): 删除迭代器对象当前指向的元素

  public class IteratorDemo2 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("b");list.add("c");list.add("d");Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();if("b".equals(s)){//指向谁,那么此时就删除谁.it.remove();}}System.out.println(list);}
  }
  

2.3.2 增强for

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
  • 实现Iterable接口的类才可以使用迭代器和增强for
  • 简化数组和Collection集合的遍历

• 格式

  ​ for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {

  ​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

  ​ }

• 代码

  public class MyCollectonDemo1 {public static void main(String[] args) {ArrayList<String> list =  new ArrayList<>();list.add("a");list.add("b");list.add("c");list.add("d");list.add("e");list.add("f");//1,数据类型一定是集合或者数组中元素的类型//2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素//3,list就是要遍历的集合或者数组for(String str : list){System.out.println(str);}}
  }
  

• 细节点注意：

1.报错NoSuchElementException

2.迭代器遍历完毕，指针不会复位

3.循环中只能用一次next方法

4.迭代器遍历时，不能用集合的方法进行增加或者删除

public class A04_CollectionDemo4 {public static void main(String[] args) {/*迭代器的细节注意点：1.报错NoSuchElementException2.迭代器遍历完毕，指针不会复位3.循环中只能用一次next方法4.迭代器遍历时，不能用集合的方法进行增加或者删除暂时当做一个结论先行记忆，在今天我们会讲解源码详细的再来分析。如果我实在要删除：那么可以用迭代器提供的remove方法进行删除。如果我要添加，暂时没有办法。(只是暂时)*///1.创建集合并添加元素Collection<String> coll = new ArrayList<>();coll.add("aaa");coll.add("bbb");coll.add("ccc");coll.add("ddd");//2.获取迭代器对象//迭代器就好比是一个箭头，默认指向集合的0索引处Iterator<String> it = coll.iterator();//3.利用循环不断的去获取集合中的每一个元素while(it.hasNext()){//4.next方法的两件事情：获取元素并移动指针String str = it.next();System.out.println(str);}//当上面循环结束之后，迭代器的指针已经指向了最后没有元素的位置//System.out.println(it.next());//NoSuchElementException//迭代器遍历完毕，指针不会复位System.out.println(it.hasNext());//如果我们要继续第二次遍历集合，只能再次获取一个新的迭代器对象Iterator<String> it2 = coll.iterator();while(it2.hasNext()){String str = it2.next();System.out.println(str);}}
}

2.3.3 lambda表达式

​ 利用forEach方法，再结合lambda表达式的方式进行遍历

public class A07_CollectionDemo7 {public static void main(String[] args) {/* lambda表达式遍历：default void forEach(Consumer<? super T> action):*///1.创建集合并添加元素Collection<String> coll = new ArrayList<>();coll.add("zhangsan");coll.add("lisi");coll.add("wangwu");//2.利用匿名内部类的形式//底层原理：//其实也会自己遍历集合，依次得到每一个元素//把得到的每一个元素，传递给下面的accept方法//s依次表示集合中的每一个数据/* coll.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});*///lambda表达式coll.forEach(s -> System.out.println(s));}
}

三 .List集合

3.1List集合的概述和特点

• List集合的概述
  • 有序集合,这里的有序指的是存取顺序
  • 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
  • 与Set集合不同,列表通常允许重复的元素
• List集合的特点
  • 存取有序
  • 可以重复
  • 有索引

3.2List集合的特有方法

• 方法介绍

  方法名	描述
  void add(int index,E element)	在此集合中的指定位置插入指定的元素
  E remove(int index)	删除指定索引处的元素，返回被删除的元素
  E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
  E get(int index)	返回指定索引处的元素

• 示例代码

  public class MyListDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");//method1(list);//method2(list);//method3(list);//method4(list);}private static void method4(List<String> list) {//        E get(int index)		返回指定索引处的元素String s = list.get(0);System.out.println(s);}private static void method3(List<String> list) {//        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素//被替换的那个元素,在集合中就不存在了.String result = list.set(0, "qqq");System.out.println(result);System.out.println(list);}private static void method2(List<String> list) {//        E remove(int index)		删除指定索引处的元素，返回被删除的元素//在List集合中有两个删除的方法//第一个 删除指定的元素,返回值表示当前元素是否删除成功//第二个 删除指定索引的元素,返回值表示实际删除的元素String s = list.remove(0);System.out.println(s);System.out.println(list);}private static void method1(List<String> list) {//        void add(int index,E element)	在此集合中的指定位置插入指定的元素//原来位置上的元素往后挪一个索引.list.add(0,"qqq");System.out.println(list);}
  }
  

3.3List集合的五种遍历方式

1. 迭代器
2. 列表迭代器
3. 增强for
4. Lambda表达式
5. 普通for循环

代码示例：

//创建集合并添加元素
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");//1.迭代器
/*Iterator<String> it = list.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);
}*///2.增强for
//下面的变量s，其实就是一个第三方的变量而已。
//在循环的过程中，依次表示集合中的每一个元素
/* for (String s : list) {System.out.println(s);}*///3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
//并把每一个元素传递给下面的accept方法
//accept方法的形参s，依次表示集合中的每一个元素
//list.forEach(s->System.out.println(s) );//4.普通for循环
//size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素
/*for (int i = 0; i < list.size(); i++) {//i:依次表示集合中的每一个索引String s = list.get(i);System.out.println(s);}*/// 5.列表迭代器
//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的//额外添加了一个方法：在遍历的过程中，可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){String str = it.next();if("bbb".equals(str)){//qqqit.add("qqq");}
}
System.out.println(list);

3.4 细节点注意：

List系列集合中的两个删除的方法

1.直接删除元素
2.通过索引进行删除

代码示例:

//List系列集合中的两个删除的方法
//1.直接删除元素
//2.通过索引进行删除//1.创建集合并添加元素
List<Integer> list = new ArrayList<>();list.add(1);
list.add(2);
list.add(3);//2.删除元素
//请问：此时删除的是1这个元素，还是1索引上的元素？
//为什么？
//因为在调用方法的时候，如果方法出现了重载现象
//优先调用，实参跟形参类型一致的那个方法。//list.remove(1);//手动装箱，手动把基本数据类型的1，变成Integer类型
Integer i = Integer.valueOf(1);list.remove(i);System.out.println(list);

四.泛型

在Java中，泛型（Generics） 是一种允许在类、接口和方法中使用类型参数的机制。通过使用泛型，可以实现更加通用且类型安全的代码。泛型的引入主要是为了提供代码的复用性、类型安全性，并且避免了大量的强制类型转换。

4.1 泛型的基本语法

4.1.1泛型类

泛型类是定义时使用了泛型类型的类，它允许在创建对象时指定类型。

public class Box<T> {private T value;public void set(T value) {this.value = value;}public T get() {return value;}
}public class Main {public static void main(String[] args) {Box<Integer> integerBox = new Box<>();integerBox.set(10);System.out.println(integerBox.get());  // 输出 10Box<String> stringBox = new Box<>();stringBox.set("Hello");System.out.println(stringBox.get());  // 输出 Hello}
}

这里的表示一个类型参数，可以在创建Box类的实例时指定类型（如Integer、String等）。这样，Box类就可以被复用，而不需要为每种类型写多个类。

4.1.2 泛型方法

泛型方法是定义时方法的参数或者返回值使用了泛型类型。

public class GenericMethodExample {// 泛型方法public static <T> void printArray(T[] array) {for (T element : array) {System.out.println(element);}}public static void main(String[] args) {Integer[] intArray = {1, 2, 3, 4};String[] stringArray = {"Apple", "Banana", "Cherry"};printArray(intArray);  // 输出 1 2 3 4printArray(stringArray);  // 输出 Apple Banana Cherry}
}

这里的声明的是方法的类型参数，表示printArray方法可以接受任何类型的数组。

4.1.3 泛型接口

泛型接口允许接口的方法使用泛型类型。

interface Pair<K, V> {K getKey();V getValue();
}public class KeyValuePair<K, V> implements Pair<K, V> {private K key;private V value;public KeyValuePair(K key, V value) {this.key = key;this.value = value;}public K getKey() {return key;}public V getValue() {return value;}
}public class Main {public static void main(String[] args) {Pair<String, Integer> pair = new KeyValuePair<>("Age", 25);System.out.println("Key: " + pair.getKey());   // 输出 Key: AgeSystem.out.println("Value: " + pair.getValue());  // 输出 Value: 25}
}

这个例子展示了一个泛型接口Pair，其中K和V分别是键和值的类型。

4.2 泛型的边界

你可以使用通配符（?）来限制泛型类型的范围，这叫做泛型边界。

4.2.1 上限通配符（extends）

上限通配符? extends T表示类型参数必须是T或T的子类。

public static void printNumbers(List<? extends Number> list) {for (Number number : list) {System.out.println(number);}
}public static void main(String[] args) {List<Integer> intList = List.of(1, 2, 3);List<Double> doubleList = List.of(1.1, 2.2, 3.3);printNumbers(intList);  // 输出 1 2 3printNumbers(doubleList);  // 输出 1.1 2.2 3.3
}

这里，? extends Number表示printNumbers方法可以接受任何Number类的子类，如Integer、Double等。

4.2.2 下限通配符（super）

下限通配符? super T表示类型参数必须是T或T的父类。

public static void addNumbers(List<? super Integer> list) {list.add(10);  // 可以安全地添加Integer类型
}public static void main(String[] args) {List<Number> numberList = new ArrayList<>();addNumbers(numberList);System.out.println(numberList);  // 输出 [10]
}

这里，? super Integer表示addNumbers方法可以接受Integer或Integer的父类的集合。

4.3 泛型的优点

• 类型安全：泛型提供了类型检查，使得你在编译时可以检查类型的一致性，从而避免运行时的ClassCastException。
• 代码重用：泛型允许你编写可重用的代码，不需要为不同的类型编写多个类。
• 更简洁：避免了强制类型转换，让代码更加清晰简洁。

4.4泛型的类型擦除

Java的泛型是通过类型擦除（Type Erasure）实现的，这意味着在编译时，泛型类型信息会被擦除，转而用Object来替代。由于类型擦除，泛型类和泛型方法在运行时无法直接访问到具体的泛型类型。

例如，下面的代码：

Box<Integer> box = new Box<>();
box.set(10);
Box<String> stringBox = new Box<>();
stringBox.set("Hello");

在编译后，Box 和 Box 会被擦除为 Box，因此你无法通过反射等方式获取到Integer或String的具体类型。

五 Set集合

在 Java 中，Set 是一个集合接口，它继承自 Collection 接口，表示不允许重复元素的集合。Set 中的元素是无序的（即没有索引）。与列表（List）不同，Set 集合不允许包含重复的元素。

5.1Set集合概述和特点

• 不可以存储重复元素
• 没有索引,不能使用普通for循环遍历

5.2Set集合的使用【应用】

存储字符串并遍历

public class MySet1 {public static void main(String[] args) {//创建集合对象Set<String> set = new TreeSet<>();//添加元素set.add("ccc");set.add("aaa");set.add("aaa");set.add("bbb");//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }//遍历集合Iterator<String> it = set.iterator();while (it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("-----------------------------------");for (String s : set) {System.out.println(s);}}
}

5.3 常见的 Set 接口实现有：

• List item

HashSet:

• 基于哈希表实现，元素是无序的，插入的顺序不一定被保留。
• 查找和插入操作的时间复杂度为 O(1)（在理想情况下）。

LinkedHashSet:

• 基于哈希表实现，元素的插入顺序被保留。
• 性能相较于 HashSet 会稍差一些，因为要维护元素的插入顺序。

TreeSet:

• 基于红黑树实现，元素会按照自然顺序（或者通过构造时提供的 Comparator）进行排序。
• 查找、插入、删除操作的时间复杂度为 O(log n)。

5.4 常用的 Set 方法

• add(E e)：添加元素，返回 true 如果集合中没有该元素。
• remove(Object o)：删除指定元素，返回 true 如果成功删除。
• contains(Object o)：检查集合中是否包含指定元素。
• size()：返回集合中元素的数量。
• isEmpty()：判断集合是否为空。
• clear()：清空集合中的所有元素。
• iterator()：返回集合的迭代器，用于遍历集合。

import java.util.*;public class SetExample {public static void main(String[] args) {// 创建一个 HashSet 实例Set<String> set = new HashSet<>();// 添加元素set.add("Apple");set.add("Banana");set.add("Orange");// 添加重复元素，不会被添加set.add("Apple");// 打印集合内容System.out.println("Set contains: " + set);// 检查元素是否存在System.out.println("Contains 'Banana': " + set.contains("Banana"));// 删除元素set.remove("Banana");// 打印删除后的集合System.out.println("After removal: " + set);// 遍历集合for (String fruit : set) {System.out.println(fruit);}}
}