【高级编程】万字整理集合框架 迭代器 泛型(含方法案例)

文章目录

• • 集合框架
  • 集合接口
  • 集合类
  • • ArrayList
    • LinkedList
    • HashSet
  • [迭代器 Iterator](#迭代器 Iterator)
  • [Map 接口](#Map 接口)
  • 泛型
  • [Collections 工具类](#Collections 工具类)

集合框架

如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象------可以使用Java集合框架

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util 包中。Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List 、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList 、LinkedList 、HashSet 、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

• 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象。
• 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
• 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序，这些算法实现了多态，那是因为相同的方法可以在相似的接口上有着不同的实现。Collections提供了对集合进行排序、遍历等多种算法实现

集合接口

接口	描述
Collection 接口	最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。 Collection 接口存储一组不唯一，无序的对象。
List 接口	有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。 List 接口存储一组不唯一，有序（插入顺序）的对象。
Set 接口	具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。 Set 接口存储一组唯一，无序的对象。
Map 接口	Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

Set和List的区别

• Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
• Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
• List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

集合类

ArrayList：内部使用数组 实现，遍历查询效率高。

LinkedList：内部使用双向链表 实现，增删改效率高。

ArrayList

语法：ArrayList<Type> listName = new ArrayList<>();

或接口引用实现类 ：List list = new ArrayList<>();

实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高

• ArrayList 类是List 接口的一个具体实现类

• ArrayList 对象实现了可变大小的数组

• 随机访问和遍历元素时，它提供更好的性能

ArrayList 常用方法

方法名	说明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

Collection 接口常用通用方法还有：clear()、isEmpty()、iterator()、toArray()

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        // 创建集合
        List list = new ArrayList<>();

        // add(Object o) 末尾添加元素
        list.add("张三"); // 0
        list.add("李四"); // 1
        list.add("王五"); // 2

        // add(int index,Object o) 指定位置插入
        list.add(1, "李四2");

        // 打印集合中所有信息
        System.out.println(Arrays.toString(list.toArray()));

        // 使用循环打印集合信息
        for (Object obj : list) {
            System.out.println(obj.toString());
        }

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // get(int index) 调用集合中的数据
        String val = list.get(2).toString();
        System.out.println(val);

        // size() 获得集合大小
        int listSize = list.size();
        System.out.println("集合长度===" + listSize);

        //  remove(int index) 根据下标删除集合内容
        list.remove("1");

        // remove(Object o) 根据指定内容删除集合元素
        list.remove("王五");
        System.out.println("删除后，集合长度===" + list.size());

        // contains(Object o) 查找集合中是否存在指定元素
        boolean bool =list.contains("张三");
        System.out.println("是否存在===" + bool);

        // clear() 清除集合中所有内容
        list.clear();
        System.out.println("clear后，集合长度===" + list.size());

        // isEmpty() 判断是否为空
        System.out.println("判断集合是否为空:" + list.isEmpty());
    }
}

LinkedList

语法：LinkedList<Type> listName = new LinkedList<>();

或接口引用实现类 ：List list = new LinkedList<>();

采用链表存储方式，插入、删除元素时效率比较高

• LinkedList 类是List 接口的一个具体实现类

• LinkedList 类用于创建链表数据结构

• 插入或者删除元素时，它提供更好的性能

LinkedList 常用方法

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

LinkedList<String> list = new LinkedList<>();
list.addFirst("Cherry");
list.addFirst("Banana");
list.addFirst("Apple");
System.out.println(list); // 输出: [Apple, Banana, Cherry]

System.out.println(list.get(1)); // 获取索引为1的元素并输出: Banana

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

list.remove("Blueberry"); // 删除第一次出现的 "Blueberry"
list.remove(1); // 删除索引为1的元素 ("Cherry")
System.out.println(list); // 输出: [Apple]

HashSet

语法：HashSet<Type> setName = new HashSet<>();

或接口引用实现类 ：Set set = new HashSet<>();

Set 接口存储一组唯一，无序的对象。HashSet 是Set 接口常用的实现类

Set 中存放对象的引用

Set set = new HashSet();
String s1 = new String("java");
String s2 = s1;
String s3 = new String("JAVA");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size()); // 2

System.out.println(set);        // [JAVA, java]
for(Object obj:set){
    System.out.println(obj); // JAVA java
}

Set 接口采用对象的equals() 方法比较两个对象是否相等，从而判断加入对象是否已经存在

Set set = new HashSet();
String s1 = new String("java");
String s2 = s1;
String s3 = new String ("java");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set.size()); // 1

HashSet 是Set 接口常用的实现类

Set newsTitleSet = new HashSet();
NewTitle car = new NewTitle(1, "汽车", "管理员");
//增加元素
newsTitleSet.add(car);
//获取元素个数
System.out.println("新闻标题数目为：" + newsTitleList.size() + "条");

Set 接口不存在下标，因此不存在get() 方法，也无法使用常规 for 循环遍历。

newsTitleSet.get(0); ❌

迭代器 Iterator

如何遍历Set 集合

一般遍历数组都是采用 for 循环或者增强 for，这两个方法也可以用在集合框架，还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或 ListIterator接口。ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素。

• 获取Iterator ：Collection 接口的 iterator() 方法

• Iterator的方法

  boolean hasNext(): 判断是否存在另一个可访问的元素

  Object next(): 返回要访问的下一个元素

List<String> list=new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("HAHAHAHA");

//方法1：通过迭代器Iterator实现遍历 
Iterator<String> ite = list.iterator();
while(ite.hasNext()){
    System.out.println(ite.next());
}

//方法2：增强型for循环
for (String str : list) {  //for(int i=0;i<list.size();i++)
    System.out.println(str);
}

//把链表变为数组相关的内容进行遍历
String[] strArray= new String[list.size()];
list.toArray(strArray);
for(int i=0;i<strArray.length;i++){ //for(String str:strArray)
    System.out.println(strArray[i]);
}

Map 接口

Map 以键值对的方式进行存储数据（key-value），key不能重复。Map 接口专门处理键值映射数据的存储，可以根据键实现对值的操作。其实现类有 HashMap TreeMap LinkedHashMap 最常用的实现类是 HashMap

Map 接口常用方法

方法名	说明
Object put(Object key, Object val)	以"键-值"对的方式进行存储。如果 Map 中已经存在这个键，那么它的旧值会被新值替换。
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove(Object key)	删除由指定的键映射的"键-值对"
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在由指定的键映射的"键-值对"，返回true
boolean containsValue(Object value)	如果存在由指定的值映射的"键-值对"，返回true

// 创建一个 HashMap 实例 
Map<String, String> map = new HashMap<>();

// 1. put(K key, V value) 向 map 中放入数据
map.put("1", "Apple");
map.put("2", "Banana");
map.put("3", "Cherry");
System.out.println("打印集合: " + map);

// 2. get(Object key) 根据 key 获得 value
System.out.println("Value for key '2': " + map.get("2"));

// 3. containsKey(Object key)
System.out.println("Contains key '1': " + map.containsKey("1"));
System.out.println("Contains key '4': " + map.containsKey("4"));

// 4. containsValue(Object value)
System.out.println("Contains value 'Cherry': " + map.containsValue("Cherry"));
System.out.println("Contains value 'Grapes': " + map.containsValue("Grapes"));

// 5. remove(Object key) 根据 key 移除元素
map.remove("3");
System.out.println("After remove key '3': " + map);

// 6. size() 获得集合长度
System.out.println("Size of the map: " + map.size());

// 7. isEmpty() 检查 Map 是否为空。
System.out.println("Is map empty: " + map.isEmpty());

// 8. clear() 清除 Map 中的所有键值对。
map.clear();
System.out.println("After clear: " + map);
System.out.println("Is map empty after clear: " + map.isEmpty());

// 9. keySet() 返回键的集合
map.put("1", "Apple");
map.put("2", "Banana");
map.put("3", "Cherry");
System.out.println("Keys in the map: " + map.keySet());

// 10. values() 返回值的集合
System.out.println("Values in the map: " + map.values());

// 11. entrySet() 返回 Map 中所有键值对的集合 Set<Map.Entry<K, V>> 每个 Map.Entry 对象代表一个键值对
System.out.println("Entries in the map: " + map.entrySet());

//循环打印
set keys = map.keyset(); //获得所有的 key 返回 set 集合
Iterator it = keys.iterator();
while(it.hasNext()){
    Object key = it.next();
    system.out.printin(key + ": " + map.get(key));
}

遍历Map 集合

Map<String, String> map = new HashMap<>();
map.put("1", "A");
map.put("2", "B");
map.put("3", "C");
//方法1：通过迭代器Iterator实现遍历 
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, String> entry = iterator.next();
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
//方法2：增强型for循环
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
//方法3：键值对
System.out.println(map.entrySet());

泛型

将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性。本质是参数化类型。

通过泛型可以解决以下强制类型转换时容易出现的异常问题：

• List 的 get(int index) 方法获取元素

• Map 的 get(Object key) 方法获取元素

• Iterator 的 next() 方法获取元素

JDK5.0使用泛型改写了集合框架中的所有接口和类

泛型的定义

• 泛型接口
• 泛型类
• 泛型方法

泛型集合及使用

泛型集合可以约束集合内的元素类型。

即：把数据类型当作参数进行传递，且传递的数据类型必须是引用数据类型。

典型泛型集合ArrayList<E>、HashMap<K,V>

• <E>、<K,V>表示该泛型集合中的元素类型

• 泛型集合中的数据不再转换为Object

除了指定了集合中的元素类型外，泛型集合和集合的用法完全一样

List<Integer> scores = new ArrayList<Integer>();
set<Double> sets = new Hashset<Double>();
Map<String,List<Integer>> maps = new HashMap<>();

Collections 工具类

Java 集合框架将针对不同数据结构算法的实现都保存在工具类中

Collections 类定义了一系列用于操作集合的静态方法

Collections 类常用方法

Collections 和 Collection 不同，前者是集合的操作类，后者是集合接口

Collections 提供的常用静态方法

• sort():排序
• max():查找最大值
• min():查找最小值

Collections 类可以对集合进行排序、查找和替换操作

List<Integer> list = new ArrayList<>();
Tist.add(88);Tist.add(55);Tist.add(33);Tist.add(99);Tist.add(77);
// 获得集合中最大的值
int max = Collections.max(list);
System.out.printin("max: " + max);
// 获得集合中最小的值
int min = Collections.min(list);
System.out.printin("min: " + min):
// 升序
Collections.sort(list);
System.out.printin(list);
// 降序
Collections.reverse(list);
System.out.printin(list):
// 查询指定内容是否存在
int i = Collections.binarysearch(list,77);
System.out.printin("i:" + i):

实现一个类的对象之间比较大小，该类要实现 Comparable 接口

重写 compareTo() 方法

public class Dog implements comparable{
    private string name;
    private int age;
    ......
    @override
    public int compareTo(object obj){
        Dog dog = (Dog)obj;
        if(dog.getAge() == this.getAge()){
            return 0; // 不换
        }else if(this.getAge() > dog.getAge()){
            return 1; // 换位置
        }else {
            return -1; // 不换
        }
    }
}