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

集合框架

如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用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提供了对集合进行排序、遍历等多种算法实现

集合接口

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 常用方法

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 常用方法

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 接口常用方法

// 创建一个 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; // 不换
        }
    }
}