Java 集合、迭代器

Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

常用集合：

Collection ：
-List 接口：元素按进入先后有序保存，可重复，插入删除会引起其他元素位置改变
-----LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素
-----ArrayList 底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素
-----Vector 底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素
------------Stack 是Vector类的实现类
-Set 接口： 仅接收一次，无序不可重复，并做内部排序，插入和删除不会引起元素位置改变 
-----HashSet 使用hash表（数组）存储元素
------------LinkedHashSet 链表维护元素的插入次序
-----TreeSet 底层实现为二叉树，元素排好序

Map ：
-----Hashtable 接口实现类， 同步， 线程安全
-----HashMap 接口实现类 ，无同步， 线程不安全
------------LinkedHashMap 双向链表和哈希表实现
------------WeakHashMap
-----TreeMap 红黑树对所有的key进行排序
-----IdentifyHashMap

一、Collection 

1.1 Java List

以下情况使用 ArrayList :

• 频繁访问列表中的某一个元素。
• 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

• 你需要通过循环迭代来访问列表中的某些元素。
• 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

1.1.1 ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

import java.util.*;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob"); //1、添加：元素到sites对象中
        sites.set(0,"Yahu"); //2、第一个参数为索引位置，第二个为要修改的值、
        sites.remove(1);     //3、删除第2个元素
        System.out.println(sites.size());         //4、输出对象长度
        for (int i = 0; i < sites.size(); i++) {  //5、for循环迭代输出
            System.out.println(sites.get(i));
        }
        for (String i : sites) {    //6、for-each循环迭代输出
            System.out.println(i);
        }
        ArrayList<Integer> li=new ArrayList<>();  //7、存放整数元素
        Collections.sort(sites);  //8、Collections类中sort() 方法可以对字符或数字列表进行排序排序
        System.out.println(sites);
    }
}

常规方法：

实例：

import java.util.*;
//遍历ArrayList
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HA");

     //第一种遍历：使用 For-Each 遍历 List
     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]);
     }
     
    //第三种遍历：使用迭代器进行相关遍历
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}
//[Hello,World,HA]

1.1.2 LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");//1、添加元素
        sites.add("Runoob");
        //2、使用 addFirst() 在头部添加元素
        sites.addFirst("BaiDu");
        //3、尾部添加
        sites.addLast("Wiki");
        //4、使用 removeFirst() 移除头部元素
        sites.removeFirst();
        //5、使用 removeLast() 移除尾部元素
        sites.removeLast();
        //6、使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst());
        //7、使用 getLast() 获取尾部元素
        System.out.println(sites.getLast());
        //9、迭代获取元素
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.println(sites.get(i));
        }
        //10、for-each 迭代
        for (String i : sites) {
            System.out.println(i);
        }
        //11、foreach遍历方式 
        sites.forEach(ites->{
        System.out.println(ites);
    });
        System.out.println(sites);
    }
}

使用较少，类比ArrayList，不举例。

1.1.3 Vector

Vector是一种老的动态数组，是线程同步的，效率很低，一般不使用。

1.2 Java Set

1.2.1 HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。HashSet 允许有 null 值，是无序的，即不会记录插入的顺序。HashSet 非线程安全， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的，在多线程访问时必须显式同步对 HashSet 的并发访问。

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  //1、重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));//2、判断元素是否存在于集合当中
        sites.remove("Taobao"); //3、删除元素，删除成功返回 true，否则为 false
        sites.clear();//4、清除全部               
        for (String i : sites) { //5、for-each 迭代
            System.out.println(i);
        }
       /*6、注意：Set无序，无法使用元素下标输出元素遍历集合
       for (int size = sites.size(), i = 0; i < size; i++)*/
       //7、foreach遍历方式 
       sites.forEach(ites->{
         System.out.println(ites);
    });
        System.out.println(sites);
    }
}

1.2.2 LinkedHashSet 

底层数据结构采用链表和哈希表共同实现，链表保证了元素的顺序与存储顺序一致，哈希表保证了元素的唯一性。线程不安全，效率高。

1.2.3 TreeSet 

底层数据结构采用二叉树来实现，元素唯一且已经排好序。

二、Map

2.1 Java Map

2.1.1 HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。HashMap 的 key 与 value 类型可以相同也可以不同，可以是字符串（String）类型的 key 和 value，也可以是整型（Integer）的 key 和字符串（String）类型的 value。HashMap 中的元素是对象，一些常见的基本类型可以使用它的包装类。

// 引入 HashMap 类      
import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        //1、创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites);
        //2、输出元素{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
        System.out.println(Sites.get(3));//输出Taobao
        for (Integer i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
          //3、返回所有 value 值
        for(String value: Sites.values()) {
          //4、输出每一个value
          System.out.print(value + ", ");
          //5、使用Entry对象遍历
      Map<String, Integer> map = new HashMap<>();
        map. put("yly", 177);
        map. put("yrc" ,176);
        map. put("zcz" ,175);
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //for迭代遍历
        for (Map.Entry<String, Integer> entry : set) {
            System.out.println(entry.getKey()+entry.getValue());
        }
    }
        }
    }
}

2.1.2 HashTable（略）

2.1.1 TreeMap（略）

三、迭代器 （Iterator）

Java迭代器是 Java 集合框架中的一种机制，是一种用于遍历集合（如列表、集合和映射等）的接口。它提供了一种统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。迭代器不是一个集合，它是一种用于访问集合的方法。以下图示主要方法。

//主要是作为循环和遍历
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> sites = new ArrayList<Integer>();
        sites.add("1");
        sites.add("2");
        sites.add("3");
        sites.add("4");
        // 获取迭代器
        Iterator<Integer> it = sites.iterator();
        // 输出集合中的第一个元素
        System.out.println(it.next());//1
        // 输出集合中的所有元素
        while(it.hasNext()) {
            System.out.print(it.next());
            }//1 2 3 4 
        for(Integer i:sites){
            System.out.print(i+" ");
            }//1 2 3 4
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  //删除小于 10 的元素
            }
            System.out.println(sites);//[]
        }
/*注意：Java 迭代器是一种单向遍历机制，即只能从前往后遍历集合中的元素，不能往回遍历。同时，在使用迭代器遍历集合时，不能直接修改集合中的元素，而是需要使用迭代器的 remove() 方法来删除当前元素*/
}

import java.util.ArrayList;
import java.util.Iterator;
 
public class Person(String name) {
    private String name;

    public void setName(String name){
    this.name = name;}
    
    public String getName(){
    return name;}
}
public class test {
    public static void main(String[] args) {
        ArrayList<Person> array = new ArrayList<Person>();
 
        Person p1 = new Person("Y");
        Person p2 = new Person("L");
        Person p3 = new Person("Y");
        Person p4 = new Person("G");
 
        array.add(p1);
        array.add(p2);
        array.add(p3);
        array.add(p4);
 
        Iterator<Person> iterator = array.iterator();
 
        for (Person pp : array){
            System.out.print(pp.getName());//Y L Y G 
        }
        
        array.forEach(obj -> System.out.print(obj.getName()));//Y L Y G 
 
        for(Person p : array){
            p.setName("B");
        }
 
        while(iterator.hasNext()){
            System.out.print(iterator.next().getName()); //B B B B
        }
 
    }
}

 参考资料：菜鸟教程 - 学的不仅是技术，更是梦想！

参考文献1：详解java集合，Collection，list，set，map汇总 - 知乎 (zhihu.com)

参考文献2：java集合超详解_java集合使用-CSDN博客

参考文献4：Java迭代器(iterator详解以及和for循环的区别)_java里迭代器能在for循环中使用么-CSDN博客