集合与泛型 - fafrkvit

集合

//接口                        Iterable
//接口         collection                                  Map
//接口        List                set      
//ArrayList LinkList   TreeSet   HashSet          HashMap  TreeMap

List list=new ArrayList();
//向上转型，声明父类接口对象  true

//collection      无序    不唯一 
//List            有序    不唯一
//Set             无序    唯一

set的无序性可以通过以下几个方面来理解：

哈希表实现：大多数编程语言中的set通常是基于哈希表（Hash Table）实现的。哈希表通过将每个元素映射到一个特定的“槽”来存储数据，这样就不会按照插入的顺序进行存储。这种映射过程通常是不可预测的，意味着元素的顺序并不是固定的，因此set的元素是无序的。
插入顺序与存储顺序不同：由于哈希表存储元素时是通过计算哈希值来确定位置的，不同的元素可能会被存储在不同的位置，即使它们是按照特定顺序插入的。这就导致了set中的元素排列顺序没有固定的规律。
不保证顺序：因为哈希表的内部实现方式，set无法保证元素的插入顺序。例如，在 Python 中使用 set 时，即使你按照特定顺序添加元素，遍历时的顺序也可能不同。

总结：set的无序性可以通过背后的哈希表实现，不会按照其插入顺序排序

ArrayList:

长度可变的数组，内存中分配连续的空间，遍历和随机访问元素效率高ArrayList<> list=new ArrayList<>();

 ArrayList<String> list=new ArrayList<>();

        for(int i=0;i<15;i++){
            list.add("432");
        }
        int n=list.size();
        System.out.println(n);
//长度可变意味，初始化时不用规定其大小

 public Main(String a,int b,String c){
        title=a;
        id=b;
        author=c;
    }
//输出类型转换逻辑
    public static void main(String[] args){
        ArrayList<Main> list=new ArrayList<>();
        list.add(new Main("32",1,"32"));
        list.add(new Main("32",1,"32"));
        list.add(new Main("32",1,"32"));
        int n=list.size();
        System.out.println(n);
        for(int i=0;i<n;i++){
            Main m=(Main)list.get(i);
            System.out.println(m.author);
            System.out.println(m.id);
            System.out.println(m.title);
        }
    }

//移除的逻辑，放入index 
list.remove(2);
        for(int i=0;i<list.size();i++){
            Main m=(Main)list.get(i);
            System.out.println(m.author);
            System.out.println(m.id);
            System.out.println(m.title);
        }
    }

遍历方法：

1.for循环注意转型

2.foreach

for(Object obj:list){}

linklist：

链表存储方式，插入删除时效率高

链表，首尾操作

list.getFirst();
list.getLast();
list.addFirst();
list.addLast();
list.removeFirst();
list.removeLast();

Set

存储唯一，无序的对象

常用HashSet实现

//常用的遍历方法
//1.for_each
Set<String> s=new Set();
for( String str:s){
        System.out.println(str);
}
//2.Iterator:可以灵活遍历，并且有删除操作
Set<Integer> s=new HashSet();
        int s0=234;
        int s1=123;
        int s2=123;
       s.add(s1);
       s.add(s2);
       s.add(s0);
       System.out.println(s.size());
        Iterator<Integer> it=s.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
//3.Stream for-each API
s.foreach(System.out::println);
//4.for_each方法
s.foreach(number -> System.out.println(number));
//5.转换为数组
Integer[] arr=s.toArray(new Integer[0]);
for(Integer num:arr){
        System.out.println(arr);
    }
String [] arr=s.toArray(new String[0]);
       for(String num:arr){
           System.out.println(num);
       }

Collection 、 List 、 Set 、 Map 接口的联系和区别

1. `Collection` 接口

概述：Collection 是 Java 集合框架中最顶层的接口，它定义了集合对象的一些基本操作，如添加、删除、包含检查等。
特点：
- Collection 是 List、Set 和其他集合类型的父接口。
- 主要定义了集合类的基本操作，如：add()、remove()、size()、isEmpty() 等。
- Collection 不包括元素的顺序（有序或无序），也不关心元素的唯一性（重复或不重复）。

2. `List` 接口

概述：List 是继承自 Collection 接口的子接口，表示一个有序的集合。它允许元素重复，并且可以通过索引访问。
特点：
- 有序：List 中的元素按照插入顺序排列。
- 允许重复：List 可以包含重复的元素。
- 可以通过索引访问元素：可以使用索引（get(index)）来访问元素。
常见实现类：
- ArrayList
- LinkedList
- Vector
- Stack

3. `Set` 接口

概述：Set 是继承自 Collection 接口的子接口，表示一个不包含重复元素的集合。
特点：
- 无序：Set 中的元素没有特定顺序。某些实现（如 TreeSet）可能按自然顺序或自定义顺序排列，但通常 HashSet 是无序的。
- 不允许重复：Set 不允许元素重复，如果尝试加入重复元素，Set 会忽略。
常见实现类：
- HashSet
- LinkedHashSet
- TreeSet

4. `Map` 接口

概述：Map 是一个与 Collection 不同的接口，它用于存储键值对（key-value pairs），每个键（key）映射到一个值（value）。Map 本身不继承 Collection 接口，但它在集合框架中是一个非常重要的接口。
特点：
- 键值对存储：Map 存储的是键值对，每个键映射到一个值，键是唯一的，但值可以重复。
- 不允许键重复：每个键只能出现一次，若试图插入重复的键，旧值会被新值替换。
- 可以通过键访问值：可以使用 get(key) 方法通过键来访问对应的值。
常见实现类：
- HashMap：基于哈希表实现，允许null值，null键
- LinkedHashMap：保证元素插入顺序的map，内置双向链表，基于哈希表
- TreeMap：基于红黑树实现，可以根据比较器的顺序或自然顺序排序
- Hashtable
- ConcurrentHashMap

put(K key, V value)：将指定的键值对插入到 Map 中。如果键已经存在，更新对应的值。
get(Object key)：根据键返回对应的值。如果找不到对应的键，则返回 null。
remove(Object key)：移除指定键的键值对。
containsKey(Object key)：检查 Map 中是否包含指定的键。
containsValue(Object value)：检查 Map 中是否包含指定的值。
keySet()：返回 Map 中所有的键，返回一个 Set 集合。
values()：返回 Map 中所有的值，返回一个 Collection 集合。
entrySet()：返回 Map 中所有的键值对，以 Set<Map.Entry<K, V>> 的形式返回。每个 Map.Entry<K, V> 都表示一个键值对。

map的遍历

1.keyset

import java.util.*;

public class Main {
    public static void main(String[] args){
        HashMap<Integer,String> map=new HashMap<>();
        map.put(0,"76");
        map.put(1,"qw");
        Set<Integer> k=map.keySet();
        for(Integer ks:k) {
            System.out.println(ks+map.get(ks));
        }


    }
}

2.`entrySet()` 方法返回 `Map` 中所有键值对的 `Set` 集合。通过迭代 `Set` 中的 `Map.Entry<K, V>` 对象，可以同时访问键和值。

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        // 使用 entrySet() 遍历 Map
        Set<Entry<String, Integer>> entries = map.entrySet();
        for (Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

3.values

import java.util.HashMap;
import java.util.Map;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        // 使用 values() 遍历 Map 的值
        Collection<Integer> values = map.values();
        for (Integer value : values) {
            System.out.println(value);
        }
    }
}

4.foreach

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        // 使用 forEach() 遍历 Map
        map.forEach((key, value) -> {
            System.out.println(key + ": " + value);
        });
    }
}

5.遍历器Iterator

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        // 使用 Iterator 遍历 Map
        Iterator<Entry<String, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry<String, Integer> entry = iterator.next();
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

联系和区别总结

特性	`Collection`	`List`	`Set`	`Map`
接口关系	所有集合类的父接口	继承自 `Collection`	继承自 `Collection`	不继承 `Collection`
元素存储	存储任意元素	存储有序的元素	存储唯一元素	存储键值对（key-value）
元素顺序	无序或有序（取决于具体实现）	保持插入顺序	无序（`TreeSet` 有序）	无顺序（`TreeMap` 有序）
是否允许重复	依赖具体实现	允许重复	不允许重复	键不允许重复，值可以重复
常见实现类	`List`、`Set` 等集合接口的父类	`ArrayList`、`LinkedList`	`HashSet`、`TreeSet`	`HashMap`、`TreeMap`、`Hashtable`

总结：

Collection 是最基础的接口，定义了一些集合操作。
List 和 Set 都是 Collection 的子接口，前者有序且允许重复，后者无序且不允许重复。
Map 是一个特殊的接口，用来存储键值对，不直接继承 Collection，但是它是集合框架的一部分。

泛型集合的好处：

1.类型安全

2.避免强制类型转换

没有需要强转，有了会自动判断

3.增强代码复用性

public <T> void printList(List<T> list) {
    for (T item : list) {
        System.out.println(item);
    }
}

posted on 2025-02-20 22:35 fafrkvit 阅读(15) 评论(0) 收藏举报

刷新页面返回顶部

集合