11.Java集合_java要保存一组数据34356可以使用什么集合-CSDN博客

本文链接：https://blog.csdn.net/qq_55760574/article/details/126897877

1.Java集合框架概述

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器

说明：此时的存储，主要指的是内存曾米娜的存储，不涉及到持久化的存储

2.1 数组在存储多个数据方面的特点

>一旦初始化以后，长度就确定了

>数组一旦定义好了，元素的类型也就确定了，只能操作指定类型的数据了 String[] arr;int[] arr1;Object[] arr2

2.2 数组在存储多个数据方面的缺点

>一旦初始化以后，长度就不能修改

>数组中提供的方法有限、不便

>获取数组中实际元素的个数需求，数组没有现成的属性或方法

3.集合框架

Collection接口：单列集合，用来存储一个一个的对象

List接口：存储有序的、可重复的数据——“动态”数组

Set接口：存储无序的、不可重复的数据——“集合”

Map接口：双列集合，用来存储一对（key–Value）的数据——函数

HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

2.Collection接口方法

1.常用方法：

add(Object e):将元素e添加到集合中

addAll(Collection coll)

size()：获取添加的元素的个数

isEmpty():判断集合是否为空

clear()

contains(Object obj):判断集合中是否包含obj,判断时会调用obj对象所在类的equals()方法

containAll(Collection coll1):判断coll1中的元素是否凑存在于当前集合中

remove(Object obj):从当前集合中删除obj元素

removeAll（Collection coll1）：差集：从当前集合中移除coll1中相同的所有的元素

retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合

equals(Object obj):判断当前集合和形参是否相同

hashCode():返回当前对象的哈希值

集合–>数组：toArray()

iterator():返回iterator接口的实例，用于遍历集合元素

2.Collection集合与数组转换

//集合-->数组：toArray()
Object[] arr=coll.toArray();
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
//数组-->集合
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);
List arr1 = Arrays.asList(new int[]{123,456});
System.out.println(arr1);
System.out.println(arr1.size());

List arr2 = Arrays.asList(new Integer[]{123,456});
System.out.println(arr2);
System.out.println(arr2.size());

3.Collection集合存储对象

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()

3.Iterator迭代器接口

1.遍历Collection的两种方法：

①使用迭代器Iterator ②foreach循环

2.java.utils包下定义的迭代器接口Iterator

2.1、如何获取实例：coll.iterator()返回一个迭代器实例

2.2、代码实现

iterator():返回iterator接口的实例，用于遍历集合元素
 * 1.内部的方法hasNext()和next()
 * 2.集合对象每次调用Iterator()方法都得到一个全新的迭代器对象、默认游标都在集合的第一个元素之前
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
    //next()：①指针下移②下移以后集合位置上的元素返回
    System.out.println(iterator.next());
}

2.3、remove()的使用：

//remove()
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry", 20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();

while (iterator.hasNext()){
    Object obj=iterator.next();
    if("Tom".equals(obj)){
        iterator.remove();
    }
}

3.foreach循环

3.1、代码实现

@Test
public void test1(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry", 20));
    coll.add(new String("Tom"));
    coll.add(false);

    //for(集合中元素的类型 局部变量 ：集合对象)
    for (Object obj :
            coll) {
        System.out.println(obj);
    }
}
//内部仍然调用了迭代器

3.2、遍历数组举例

@Test
public void test2(){
    int[] arr =new int[]{1,2,3,4,5,6};
    for (int i :
            arr) {
        System.out.println(i);
    }
}

4.Collection子接口：List

1.存储数据特点：

ArrayList:作为List接口的主要实现类：线程不安全的、效率高;底层使用Object[] elementData存储

LinkedList:对于频繁的掺入、删除操作，使用此类效率比ArrayList高;双链表存储

Vector:作为List接口的古老实现类：线程安全的、低效率的;底层使用Object[] elementData存储

ArrayList\LinkedList\Vector三者的异同

同：三各类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同：见上

2.常用方法：

增：add(Object obj)
删：remove(int index)/remove(Object obj)
改：set(int index,Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：
方式一：Iterator迭代器方式
方式二：增强for循环
方式三：普通for循环

3.常用实现类：

ArrayList:作为List接口的主要实现类：线程不安全的、效率高;底层使用Object[] elementData存储

LinkedList:对于频繁的掺入、删除操作，使用此类效率比ArrayList高;双链表存储

Vector:作为List接口的古老实现类：线程安全的、低效率的;底层使用Object[] elementData存储

4.存储的元素要求：添加的对象所在的类要重写equals（）方法

ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);

5.Collection子接口：Set

1.Set:存储无序的，不可重复的数据

1.无序性:不等于随机性

2.不可重复性:保证添加的元素按照equals判断时，不能返回true

2.添加元素的过程：以HashSet为例

首先调用元素a所在类的hashcode（）方法，计算元素a的哈希值
然后哈希值计算出在hashset底层数组中的存放位置（索引位置）判断数据在此位置上是否已经有元素
如果没有其他元素：则添加成功
如果有其他元素b，则比较a和b的hash值
如果hash值不同，则a添加成功
如果hash值相同，进而需要调用a的类的equals（）方法
返回true，添加失败
返回false，添加成功

HashSet底层：数组+链表（jdk7）

3.常用方法：

Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法

4.常用实现类：

HashSet：作为Set接口的主要实现类：线程不安全，可以存储null值

LinkedHashSet：作为HashSet的子类，遍历器内部数据是，可以按照添加的顺序遍历，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

TreeSet：可以按照添加对象的指定属性，进行排序

5.存储对象所在类的要求：

HashSet和LinkedHashSet：

要求：像Set（主要指HashSet和LinkedHashSet）中添加的数据，其所在的类一定要重写hashCode（）和equals（）

要求：重写的hashCode（）和equals（）尽可能保持一致性，相等的对象必须具有相等的散列码

重写两个方法的小技巧：对象中用作equals（）方法比较的field，都应该用来计算hashCode值

TreeSet：

1.自然排序中，比较两个对象是否相同的标准是：compareTo（）返回0，不再是equals（）

2.定制排序中，比较两个对象是否相同的标准是：compare（）返回0，不再是equals（）

Set set = new HashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);

6.Map接口

1.概念

Map：双列数据，用于存储key-value对的数据—类似于函数

HashMap：作为Map的主要实现类；线程不安全，效率高；存储null的key和value

LinkedHashMap：保证在遍历map元素是，可以按照添加的顺序实现遍历

原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素

对于频繁的遍历操作，此类执行效率高于HashMap

TreeMap：保证按照添加的key-value对进行排序，实现排序遍历，此时考虑key的自然排序或定制排序

底层使用红黑树

Hashtable：作为古老的实现类；线程安全，效率低；不存储null的key和value

properties：常用来处理配置文件 key和value都是String类型

2.Map结构的裂解

Map中的key：无序的、不可重复的、使用Set存储所有的key —>key所在的类要重写equals（）和hashCode（）（以HashMap为例）

Map中的value：无序的、可重复的使用Collection存储所有的value

一个键值对：key-value构成了一个Entry对象

Map中的entry：无序的、不可重复的、使用Set存储所有的entry

3.Map中定义的方法：

添加、删除、修改操作
Object put(Object key,Object value):将指定key-value添加到（或修改）当前map对象中
void putAll（Map m）：将m中的所有key-value对存放到当前map中
Object remove（Object key）：移除指定key的key-value对，并返回value
void clear（）：清空当前map中的所有数据
元素的查询的操作
Object get（Object key）：获取指定key对应的value
boolean containsKey（Object key）：是否包含指定的key
boolean contains Key（Object key）：是否包含指定的value
int size（）：返回map中key-value对的个数
boolean isEmpty（）：判断当前map是否为空
boolean equals（Object obj）：判断当前map和参数对象obj是否相等
元视图操作的方法
Set keySet（）：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet（）：返回所有key-value对构成的Set集合

 ```java
 public void test4(){
     Map map = new HashMap();
     map.put("AA",123);
     map.put(45,123);
     map.put("BB",56);
     //遍历所有的key集
     Set set = map.keySet();
     Iterator iterator = set.iterator();
     while(iterator.hasNext()){
         System.out.println(iterator.next());
     }
 
     //遍历所有的value集
     Collection values = map.values();
     for (Object obj :
             values) {
         System.out.println(obj);
     }
 
     Set set1 = map.entrySet();
     Iterator iterator1 = set1.iterator();
     while(iterator1.hasNext()){
         Object obj = iterator1.next();
         Map.Entry entry = (Map.Entry) obj;
         System.out.println(entry.getKey()+"---"+entry.getValue());
 
     }
 ```

7.Collections工具类

Collections：操作Collection、Map的工具类

reverse（List）：反转List中元素的顺序
shuffle（List）：对List集合元素进行随机排序
sort（List）：根据元素的自然顺序对指定List集合元素按升序排序
sort（List，Comparator）：根据指定的Comparator产生的顺序对List集合元素进行排序
swap（List，int，int）：将指定List集合中的i处元素和j处元素进行交换
*
Object max（Collection）：根据元素的自然排序，返回指定集合中的最大元素
Object max（Collection，Comparator）：根据Comparator指定的顺序，返回给指定集合中的最大元素
Object min（Collection）：
Object min（Collection，Comparator)
int frequency（Collection，Object）：返回指定集合中指定元素的出现次数
void copy（List dest，List src）将src中的内容复制到dest中

boolean replaceAll（List list，Object oldVal，Object newVal）：是用心之替换List对象

public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
//        System.out.println(dest);
        List dest= Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());
        Collections.copy(dest,list);
        System.out.println(dest);

    }