集合框架

最新推荐文章于 2024-04-27 09:13:51 发布

小方f

最新推荐文章于 2024-04-27 09:13:51 发布

阅读量70

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_43511745/article/details/107571705

版权

8.java中的集合框架

8.1集合框架的体系结构

集合–集中合并数据----文件夹是一个集合的表现

--统一管理/处理数据
框架–jdk提供操作类库
集合框架–jdk提供的对集中合并数据进行统一管理/处理的开发类库。

交由集合统一管理/处理的数据有两种表现形式：

单列数据【独立的一个数据–数字，字符串,…】

100 ,”hello”
键值对数据【一个数据是由键和建对应的值组成】

书的目录就是一种典型的键值对数据

8.2 Conllection与Map

Jdk提供的处理单列数据的开发类库

1、Collection接口是Jdk提供的处理单列数据的顶级接口。

2、Collection接口的子接口List接口处理有顺序的单列数据。

List接口可以有重复的数据元素，按照顺序区分。

ArrayList类
LinkedList类

3、Collection接口的子接口Set接口处理没有顺序的单列数据。

Set接口不能有重复的数据元素，【重复的元素被视为同一个】

HashSet类
LinkedHashSet类

在这里插入图片描述

Map集合

Map主要分为HashMap，HashTable和SortedMap以及TreeMap和Properties

HashMap
实现了Map、Cloneable、java.io.Serializable接口，继承AbstractMap，是基于Hash表和Map来实现的，同时也是一个散列表，它存储的内容是键值对(key-value)映射，HashMap拥有2个至关重要的东西，那就是加载因子和初始容量，当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。现在我们看看Hashmap 的4个构造函数,同时也不是线程安全的。
// 默认构造函数。
HashMap()

// 指定“容量大小”的构造函数
HashMap(int capacity)

// 指定“容量大小”和“加载因子”的构造函数
HashMap(int capacity, float loadFactor)

// 包含“子Map”的构造函数
HashMap(Map<? extends K, ? extends V> map)

HashTable
类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法，被synchronized修饰。

sortedMap
SortedMap接口主要提供有序的Map实现,

List与Set

List 是可重复集合，Set 是不可重复集合，这两个接口都实现了 Collection 父接口。

Map 未继承 Collection，而是独立的接口，Map 是一种把键对象和值对象进行映射的集合，它的每一个元素都包含了一对键对象和值对象，Map 中存储的数据是没有顺序的，其 key 是不能重复的，它的值是可以有重复的。

List 的实现类有 ArrayList，Vector 和 LinkedList：

ArrayList 和 Vector 内部是线性动态数组结构，在查询效率上会高很多，Vector 是线程安全的，相比 ArrayList 线程不安全的，性能会稍慢一些。

LinkedList：是双向链表的数据结构存储数据，在做查询时会按照序号索引数据进行前向或后向遍历，查询效率偏低，但插入数据时只需要记录本项的前后项即可，所以插入速度较快。

Set 的实现类有 HashSet 和 TreeSet；

HashSet：内部是由哈希表（实际上是一个 HashMap 实例）支持的。它不保证 set 元素的迭代顺序。

TreeSet：TreeSet 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序。

Map 接口有三个实现类：Hashtable，HashMap，TreeMap，LinkedHashMap；

Hashtable：内部存储的键值对是无序的是按照哈希算法进行排序，与 HashMap 最大的区别就是线程安全。键或者值不能为 null，为 null 就会抛出空指针异常。

TreeMap：基于红黑树 (red-black tree) 数据结构实现，按 key 排序，默认的排序方式是升序。

LinkedHashMap：有序的 Map 集合实现类，相当于一个栈，先 put 进去的最后出来，先进后出。

8.3 ArrayList与LinkedList

处理有顺序的单列数据
保存数据的存储空间，会自动扩展【注意与数组的区别】
可以保存任意数据类型的数据【注意与数组的区别】
数据存储结构是动态数组结构【优势：查询速度快缺点：添加/删除速度慢】

所属包：java.util

构造方法：

ArrayList() 构造一个初始容量为10的空列表。

ArrayList(Collection c) 将实现Collection接口的集合类转换成ArrayList

ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。

例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestMain {
     public static void main(String[] args) {
         //测试ArrayList的构造方法--创建对象
         //ArrayList() 构造一个初始容量为10的空列表。
         ArrayList list1=new ArrayList();
         //ArrayList(Collection c) 将实现Collection接口的集合类转换成ArrayList
         ArrayList list2=new ArrayList(list1);
         //ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
         ArrayList list3=new ArrayList(30);
         //可以利用List接口
         List list11=new ArrayList();
         List list22=new ArrayList(list11);
         List list33=new ArrayList(40);
         //可以利用Collection接口
         Collection list111=new ArrayList();
         Collection list222=new ArrayList(list111);
         Collection list333=new ArrayList(50);
     }
}

实例方法

add([E] e) 将指定的元素追加到此列表的末尾。
clear() 从列表中删除所有元素。
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

例如：

package com.click369.test2;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestMain {
   public static void main(String[] args) {
         //ArrayList中的实例方法
         ArrayList list1=new ArrayList();
         //1.add(E e) 将指定的元素追加到此列表的末尾。
         list1.add("hello");
        list1.add(true);
         list1.add(12.5);
         list1.add("hello");
         //2.size() 返回此列表中的元素数。
         System.out.println("list1的元素数="+list1.size());
         //3.clear() 从列表中删除所有元素。[清空]
         //list1.clear();
         //System.out.println("list1的元素数="+list1.size());
         //4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
         System.out.println("判断hello元素是否在list1这个集合中=="+list1.contains("hello1"));
         //5.get(int index) 返回此列表中指定位置的元素。
        //System.out.println("get(5)=="+list1.get(5));
         //6.indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
         System.out.println("hello元素在list1中第一次出现的位置=="+list1.indexOf("hello"));
         //7.lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
         System.out.println("hello元素在list1中最后一次出现的位置=="+list1.lastIndexOf("hello"));
         //8.isEmpty() 如果此列表不包含元素，则返回 true 。
        //list1.clear();
         //System.out.println("list1集合是否为空="+list1.isEmpty());
         //9.remove(int index) 删除该列表中指定位置的元素。
         //list1.remove(2);
         //System.out.println("list1的元素数="+list1.size());
         //10.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
         //list1.remove("hello");
         //System.out.println("list1的元素数="+list1.size());
         //System.out.println("get(0)=="+list1.get(0));
         //11.set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
         list1.set(0,"world");
         System.out.println("get(0)=="+list1.get(0));
         //12.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
         Object[] objs=list1.toArray();
     }
}

Iterator iterator() 以正确的顺序返回该列表中的元素的迭代器接口。【遍历ArrayList中的数据元素】

ArrayList集合的遍历

例如：

package com.click369.test3;
import java.util.ArrayList;
import java.util.Iterator;
public class TestMain {
     public static void main(String[] args) {
         //ArrayList集合的遍历
         ArrayList list=new ArrayList();
         list.add("hello");
         list.add(1001);
         list.add("world");
         list.add(true);
         list.add(12.5);
         //1.通过普通的for循环遍历ArrayList集合
         for(int i=0;i<list.size();i++){
             System.out.println("list---"+list.get(i));
         }
         //2、使用增强的for循环
         for(Object obj:list){
             System.out.println("obj---"+obj);
         }
         //3.使用Iterator iterator()迭代器
         Iterator it=list.iterator();
         while(it.hasNext()){
             Object obj=it.next();
             System.out.println("Iterator---"+obj);
         }
     }
}

LinkedList类

1.处理有顺序的单列数据

2.保存数据的存储空间，会自动扩展【注意与数组的区别】

3.可以保存任意数据类型的数据【注意与数组的区别】

4.数据存储结构是链表【火车】结构【优势：添加/删除速度快缺点：查询速度慢】

构造方法：

LinkedList() 构造一个空列表。

LinkedList(Collection c) 将实现Collection接口的集合类转换成LinkedList

例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
public class TestMain {
     public static void main(String[] args) {
         //测试LinkedList的构造方法--创建对象
         //LinkedList() 构造一个空列表。
         LinkedList list1=new LinkedList();
         //LinkedList(Collection c) 将实现Collection接口的集合类转换成LinkedList
         ArrayList alist=new ArrayList();
         LinkedList list2=new LinkedList(alist);
         //可以利用List接口
         List list11=new LinkedList();
         List list22=new LinkedList(list11);
         //可以利用Collection接口
         Collection list111=new LinkedList();
         Collection list222=new LinkedList(list111);
     }
}

实例方法与ArrayList一样：

add(E e) 将指定的元素追加到此列表的末尾。
clear() 从列表中删除所有元素。
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

LinkedList类提供了一组针对第一个元素和最后一个元素的操作方法：

addFirst(E e) 在该列表开头插入指定的元素。
addLast(E e) 将指定的元素追加到此列表的末尾
getFirst() 返回此列表中的第一个元素。
getLast() 返回此列表中的最后一个元素。
removeFirst() 从此列表中删除并返回第一个元素。
removeLast() 从此列表中删除并返回最后一个元素。
因为LinkedList类的数据存储结构是链表【火车】结构

例如：

package com.click369.test2;
import java.util.LinkedList;
public class TestMain {
     public static void main(String[] args) {
         //LinkedList中的实例方法
         LinkedList list1=new LinkedList();
         //1.add(E e) 将指定的元素追加到此列表的末尾。
         list1.add("hello");
         list1.add(true);
         list1.add(12.5);
         list1.add("hello");
         //2.size() 返回此列表中的元素数。
         //System.out.println("list1的元素数="+list1.size());
         //3.clear() 从列表中删除所有元素。[清空]
         //list1.clear();
         //System.out.println("list1的元素数="+list1.size());
         //4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
         //System.out.println("判断hello元素是否在list1这个集合中=="+list1.contains("hello"));
         //5.get(int index) 返回此列表中指定位置的元素。
         //System.out.println("get(2)=="+list1.get(2));
         //6.indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
         //System.out.println("hello元素在list1中第一次出现的位置=="+list1.indexOf("hello"));
         //7.lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
         //System.out.println("hello元素在list1中最后一次出现的位置=="+list1.lastIndexOf("hello"));
         //8.isEmpty() 如果此列表不包含元素，则返回 true 。
         //list1.clear();
         //System.out.println("list1集合是否为空="+list1.isEmpty());
         //9.remove(int index) 删除该列表中指定位置的元素。
         //list1.remove(2);
        //System.out.println("list1的元素数="+list1.size());
         //10.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
        //list1.remove("hello");
         //System.out.println("list1的元素数="+list1.size());
         //System.out.println("get(0)=="+list1.get(0));
         //11.set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
         //list1.set(0,"world");
         //System.out.println("get(0)=="+list1.get(0));
         //12.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
         //Object[] objs=list1.toArray();       
         //LinkedList类提供了一组针对第一个元素和最后一个元素的操作方法：
         //addFirst(E e) 在该列表开头插入指定的元素。
         //addLast(E e) 将指定的元素追加到此列表的末尾
         //getFirst() 返回此列表中的第一个元素。 
        //getLast() 返回此列表中的最后一个元素。
         //removeFirst() 从此列表中删除并返回第一个元素。
         //removeLast() 从此列表中删除并返回最后一个元素。
         //因为LinkedList类的数据存储结构是链表【火车】结构
    }
}

LinkedList集合的遍历

package com.click369.test3;
import java.util.Iterator;
import java.util.LinkedList;
public class TestMain {
     public static void main(String[] args) {
         //LinkedList集合的遍历
         LinkedList list=new LinkedList();
         list.add("hello");
         list.add(1001);
         list.add("world");
         list.add(true);
         list.add(12.5);
         //1.通过普通的for循环遍历ArrayList集合
         for(int i=0;i<list.size();i++){
             System.out.println("list---"+list.get(i));
         }
         //2、使用增强的for循环
         for(Object obj:list){
             System.out.println("obj---"+obj);
         }
         //3.使用Iterator iterator()迭代器
         Iterator it=list.iterator();
         while(it.hasNext()){
             Object obj=it.next();
             System.out.println("Iterator---"+obj);
         }
     }
}

8.4 HashSet与LinkedHashSet

处理的是没有顺序的单列数据【重复的元素算一个】
保存数据的存储空间，会自动扩展。
可以保存任意数据类型的数据。

构造方法：

HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
HashSet(Collection c)将实现Collection 接口的集合类转换成[HashSet]
HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子

例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
public class TestMain {
     public static void main(String[] args) {
         //测试HashSet的构造方法--创建对象
          //HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
         HashSet set1=new HashSet();
         //HashSet(Collection c)将实现Collection 接口的集合类转换成HashSet
         ArrayList list=new ArrayList();
         HashSet  set2=new HashSet(list); 
         //HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。 
         HashSet set3=new HashSet(10);
         //HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子
         HashSet set4=new HashSet(10,0.5f);
        //可以使用Set接口
         Set set11=new HashSet();
         Set set22=new HashSet(list);
         Set set33=new HashSet(30);
        Set set44=new HashSet(40,0.5f);
         //可以使用Collection接口
         Collection set111=new HashSet();
         Collection set222=new HashSet(list);
         Collection set333=new HashSet(30);
         Collection set444=new HashSet(40,0.5f);
     }
}

实例方法：

add(E e) 将指定的元素添加到此集合。
clear() 从此集合中删除所有元素。
contains(Object o) 如果此集合包含指定的元素，则返回 true 。
isEmpty() 如果此集合不包含元素，则返回 true 。
remove(Object o) 如果存在，则从该集合中删除指定的元素。
size() 返回此集合中的元素数。
toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组

例如：

package com.click369.test2;
import java.util.HashSet;
public class TestMain {
     public static void main(String[] args) {
         //HashSet中的实例方法
         HashSet set1=new HashSet();
         //1.add(E e) 将指定的元素追加到此列表的末尾。
         set1.add("hello");
         set1.add(true);
         set1.add(12.5);
         set1.add("hello");
         //2.size() 返回此列表中的元素数。
         //System.out.println("set1的元素数="+set1.size());
         //3.clear() 从列表中删除所有元素。[清空]
        //set1.clear();
        //System.out.println("set1的元素数="+set1.size());
        //4.contains(Object o) 如果此列表包含指定的元素，则返回 true 。
        System.out.println("判断hello元素是否在set1这个集合中=="+set1.contains("hello"));
         //5.isEmpty() 如果此列表不包含元素，则返回 true 。
        //set1.clear();
         //System.out.println("set1集合是否为空="+set1.isEmpty());
         //6.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
         set1.remove("hello");
         System.out.println("set1的元素数="+set1.size());
         //7.toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的[Object]数组
         Object[] objs=set1.toArray();
     }
}
HashSet集合的遍历
package com.click369.test3;
import java.util.HashSet;
import java.util.Iterator;
public class TestMain {
     public static void main(String[] args) {
         //HashSet集合的遍历
         HashSet set=new HashSet();
         set.add("hello");
         set.add(1001);
         set.add("world");
         set.add(true);
         set.add(12.5);
         //1、使用增强的for循环
         for(Object obj:set){
             System.out.println("obj---"+obj);
         }
         //2.使用Iterator iterator()迭代器
         Iterator it=set.iterator();
         while(it.hasNext()){
             Object obj=it.next();
             System.out.println("Iterator---"+obj);
         }
     }
}

LinkedHashSet类

定义结构：

public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, 
LinkedHashSet是HashSet类的子类

只要会使用HashSet，那么就一定会使用LinkedHashSet。

构造方法：

LinkedHashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
LinkedHashSet(Collection c)将实现Collection 接口的集合类转换成LinkedHashSet
LinkedHashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
LinkedHashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的

实例方法：

add(E e) 将指定的元素添加到此集合。
clear() 从此集合中删除所有元素。
contains(Object o) 如果此集合包含指定的元素，则返回 true 。
isEmpty() 如果此集合不包含元素，则返回 true 。
remove(Object o) 如果存在，则从该集合中删除指定的元素。
size() 返回此集合中的元素数。
iterator() 返回此集合中元素的迭代器。

8.5 HashMap与Hashtable与TreeMap与ConcurrentHashMap

HashMap类

可以处理键值对数据
保存键值对数据的存储空间会自动扩展。
所保存的键值对数据可以为null.[1.null=”sss” 2. “sss”=null 3. null=null]
保存的键值对数据是无序的。
不能有重复的键【重复的键算一个数据】

【键】=【值】
构造方法：

HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap(Map m) 将实现Map接口的集合类转换成HashMap

例如：

package com.click369.test1;
import java.util.HashMap;
import java.util.Map;
public class TestMain {
     public static void main(String[] args) {
         //HashMap的构造方法--创建对象
         //HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 
         HashMap map1=new HashMap();
         //HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
         HashMap map2=new HashMap(20);
         //HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
         HashMap map3=new HashMap(30,0.5f);
         //HashMap(Map m) 将实现Map接口的集合类转换成HashMap
         HashMap map4=new HashMap(map1);
         //可以利用Map接口
         Map map11=new HashMap();
         Map map22=new HashMap(20);
         Map map33=new HashMap(30,0.5f);
         Map map44=new HashMap(map33);
     }
}

HashMap常用的实例方法：

put(K key, V value) 添加键值对数据。
size() 得到集合中键值对元素的个数。
isEmpty() 判断集合书否为空
clear() 清空集合。
containsKey(Object key) 判断指定的键数据在集合中是否存在。
containsValue(Object value) 判断指定的值数据在集合中是否存在。
get(Object key)根据指定的键数据得到与这个键对应的值数据。
remove(Object key)根据指定的键数据删除整个键值对数据。
replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。

例如：

package com.click369.test2;
import java.util.HashMap;
import java.util.Map;
public class TestMain {
     public static void main(String[] args) {
         //HashMap的实例方法
         HashMap map1=new HashMap();
         //1.put(K key, V value) 添加键值对数据。
         //键或者值都可以是任意数据类型
         map1.put("hello", 1001);
         map1.put(1002,"world");
         map1.put(true, 12.5);
         map1.put(120.5, false);
         //所保存的键值对数据可以为null.
         //map1.put(null, "test"); //键为null，值不为null
         //map1.put("test",null); //键不为null，值为null
         //map1.put(null,null); ///键为null，值为null
         //不能有重复的键【重复的键算一个数据】
         //map1.put("java","test1");
         //map1.put("java","test2");
         //2.size() 得到集合中键值对元素的个数。 
         System.out.println("map1集合键值对元素的个数=="+map1.size());
         //3.isEmpty() 判断集合是否为空 
         System.out.println("map1集合判断集合是否为空=="+map1.isEmpty());
         //4.clear() 清空集合。 
         //5.containsKey(Object key) 判断指定的键数据在集合中是否存在。
         System.out.println("判断指定的键数据在集合中是否存在=="+map1.containsKey("hello"));
         //6.containsValue(Object value) 判断指定的值数据在集合中是否存在 。
         System.out.println("判断指定的值数据在集合中是否存在=="+map1.containsValue("hello"));
         //7.get(Object key)根据指定的键数据得到与这个键对应的值数据。
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get("hello"));
         //8.remove(Object key)根据指定的键数据删除整个键值对数据。
         //map1.remove(true);
         //System.out.println("map1集合键值对元素的个数=="+map1.size());
         //System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(true));
         //9.replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(1002));
         map1.replace(1002, "world", "hello");
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+map1.get(1002));
     }
}

遍历键值对对集合：

Set keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Collection values() 得到键值对集合中所有键值对数据的键数据保存到Collection集合中
Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中

例如：

public static void main(String[] args) { 
         HashMap map=new  HashMap();
         map.put(100,"zhangsan");
         map.put(12.5,true);
         map.put("test",1000);
         map.put(false,168.5);
         //Set<K> keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
         Set keyset=map.keySet();
         for(Object objkey:keyset){
             System.out.println("key==="+objkey);
         }    

         //Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
         Collection vals=map.values();
         for(Object objvalue:vals){
             System.out.println("value==="+objvalue);
         }    
         //Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
         Set  k_v_set=map.entrySet();
         for(Object obj:k_v_set){
             System.out.println(obj);
         }
    
         //遍历Map集合的方法
         HashMap<String,String> testmap=new   HashMap<String,String>();
         testmap.put("name","zhangsan");
         testmap.put("pass","123456");
         testmap.put("address","西安");
         for(Map.Entry<String,String> entry:testmap.entrySet()){
             //System.out.println("mykey=="+entry.getKey());
             //System.out.println("myvalue=="+entry.getValue());
             System.out.println("k-v=="+entry.getKey()+":"+entry.getValue());
         }
    }

Hashtable类

可以处理键值对数据
保存键值对数据的存储空间会自动扩展。
不允许null出现
不能有重复的键【重复的键算一个数据】
保存的键值对数据是无序的。

构造方法：

Hashtable() 构造一个空的 Hashtable，默认初始容量（11）和默认负载系数（0.75）。
Hashtable(int initialCapacity) 构造一个空的 Hashtable具有指定的初始容量和默认负载因子（0.75）。
Hashtable(int initialCapacity, float loadFactor) 构造一个空的 Hashtable具有指定的初始容量和负载因子。
Hashtable(Map m) 将实现Map接口的集合类转换成Hashtable

例如：

package com.click369.test1;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class TestMain {
     public static void main(String[] args) {
         //Hashtable的构造方法--创建对象
        //Hashtable() 构造一个空的 Hashtable ，默认初始容量（11）和默认负载系数（0.75）。 
         Hashtable table1=new Hashtable();
         //Hashtable(int initialCapacity) 构造一个空的 Hashtable具有指定的初始容量和默认负载因子（0.75）。
         Hashtable table2=new Hashtable(20);
         //Hashtable(int initialCapacity, float loadFactor) 构造一个空的 Hashtable具有指定的初始容量和负载因子。
         Hashtable table3=new Hashtable(30,0.5f);
         //Hashtable(Map m) 将实现Map接口的集合类转换成Hashtable
         HashMap map4=new HashMap();
         Hashtable table4=new Hashtable(map4);
         //可以利用Map接口
         Map table11=new Hashtable();
         Map table22=new Hashtable(20);
         Map table33=new Hashtable(30,0.5f);
         Map table44=new Hashtable(table33);
     }
}

实例方法：

put(K key, V value) 添加键值对数据。

size() 得到集合中键值对元素的个数。

isEmpty() 判断集合书否为空

clear() 清空集合。

containsKey(Object key) 判断指定的键数据在集合中是否存在。

containsValue(Object value) 判断指定的值数据在集合中是否存在。

get(Object key)根据指定的键数据得到与这个键对应的值数据。

remove(Object key)根据指定的键数据删除整个键值对数据。

replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。

例如：

package com.click369.test2;
import java.util.Hashtable;
public class TestMain {
     public static void main(String[] args) {
         //Hashtable的实例方法
         Hashtable table1=new Hashtable();
         //1.put(K key, V value) 添加键值对数据。
         //键或者值都可以是任意数据类型
         table1.put("hello", 1001);
         table1.put(1002,"world");
         table1.put(true, 12.5);
         table1.put(120.5, false);
         //不允许null出现
         //table1.put(null, "test"); 
         //table1.put("test",null);
         //不能有重复的键【重复的键算一个数据】
         //table1.put("java","test1");
         //table1.put("java","test2");
         //2.size() 得到集合中键值对元素的个数。 
         System.out.println("table1集合键值对元素的个数=="+table1.size());
         //3.isEmpty() 判断集合是否为空 
         System.out.println("table1集合判断集合是否为空=="+table1.isEmpty());
         //4.clear() 清空集合。 
         //5.containsKey(Object key) 判断指定的键数据在集合中是否存在。
         System.out.println("判断指定的键数据在集合中是否存在=="+table1.containsKey("hello"));
         //6.containsValue(Object value) 判断指定的值数据在集合中是否存在 。
         System.out.println("判断指定的值数据在集合中是否存在=="+table1.containsValue("hello"));
         //7.get(Object key)根据指定的键数据得到与这个键对应的值数据。
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get("hello"));
         //8.remove(Object key)根据指定的键数据删除整个键值对数据。
         table1.remove(true);
         System.out.println("table1集合键值对元素的个数=="+table1.size());
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(true));
         //9.replace(K key, V oldValue, V newValue) 根据指定的键数据替换对应的值数据。
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(1002));
         table1.replace(1002, "world", "hello");
         System.out.println("根据指定的键数据得到与这个键对应的值数据=="+table1.get(1002));
     }
}

遍历兼职对集合：

Set keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
Collection values() 得到键值对集合中所有键值对数据的键数据保存到Collection集合中
Set<Map.Entry<K,V> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中

例如：

package com.click369.test3;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestMain {
     public static void main(String[] args) {
         //Hashtable的遍历
         Hashtable<Object,Object> table1=new Hashtable<Object,Object>();
         table1.put("hello", 1001);
         table1.put(1002,"world");
         table1.put(true, 12.5);
         table1.put(120.5, false);
         //遍历所有的键数据
         //Set<K> keySet() 得到键值对集合中所有键值对数据的键数据保存到set集合中
         Set set1=table1.keySet();
         for(Object obj:set1){
             System.out.println("key=="+obj);
         }
         //使用迭代器遍历键数据对饮的set集合
         Iterator keyit=set1.iterator();
         while(keyit.hasNext()){
             System.out.println("keyit=="+keyit.next());
        }
        
         //遍历所有的值数据
         //Collection<V> values() 得到键值对集合中所有键值对数据的键数据保存到Collection<V>集合中
         Collection coll=table1.values();
         for(Object val:coll){
             System.out.println("value=="+val);
         }
         //使用迭代器遍历键数据对饮的set集合
         Iterator valit=coll.iterator();
         while(valit.hasNext()){
                      System.out.println("valit=="+valit.next());
                  }
         
         //遍历所有的键和值数据
         //Set<Map.Entry<K,V>> entrySet()得到键值对集合中所有键值对数据保存到Set<Map.Entry<K,V>>集合中
         //注意：HashMap<Object,Object> map1=new HashMap<Object,Object>();
         for(Map.Entry<Object,Object> entry : table1.entrySet()){
             Object k=entry.getKey();
             Object v=entry.getValue();
             System.out.println(k+"="+v);
         }
     }
}

在这里插入图片描述

Collections类【集合操作类的辅助类】

提供对集合进行操作的查询，复制，排序，线程安全操作的一系列静态方法

集合操作类的辅助类，与数组的辅助类【Arrays】相似。

例如：

package com.click369.test1;
import java.util.ArrayList;
import java.util.Collections;
public class TestMain {
     public static void main(String[] args) {
         //Collections类
         //是集合操作类的辅助类
         //提供了一组操作集合的静态方法【查询集合元素，复制集合中的元素进入另一个集合，为集合中的元素排序...】
         ArrayList list1=new ArrayList();
         list1.add("zhangsan");
         list1.add("lisi");
         list1.add("Lisi");
        list1.add("zhaoliu");
         //static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 返回给定集合的最大元素。 
         Object max=Collections.max(list1);
         System.out.println(max);
        //static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 返回给定集合的最小元素。 
         Object min=Collections.min(list1);
         System.out.println(min);
         System.out.println("------------------------");
         System.out.println("没有排序之前");
         for(Object obj:list1){
             System.out.println("没有排序之前=="+obj);
         }
         System.out.println("------------------------");
         // sort(List<T> list) 对指定的列表进行排序。
         Collections.sort(list1);
         System.out.println("排序之后");
         for(Object obj:list1){
             System.out.println("排序之后=="+obj);
         }
     //static <T> void copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表中,会覆盖目标列表中的对应数据元素。 
  //注意：目标集合的元素个数 >= 源集合的元素个数 ，否则java.lang.IndexOutOfBoundsException: Source does not fit in dest
         ArrayList list2=new ArrayList();
         list2.add(234);
         list2.add(547);
         list2.add(13);
         list2.add(464);
         list2.add(4565);
         list2.add(6579823);
         Collections.copy(list2, list1);
        for(Object obj:list2){
             System.out.println("list2=="+obj);
         }
    }
}

“);
for(Object obj:list1){
System.out.println(“没有排序之前==”+obj);
}
System.out.println(”------------------------");
// sort(List list) 对指定的列表进行排序。
Collections.sort(list1);
System.out.println(“排序之后”);
for(Object obj:list1){
System.out.println(“排序之后==”+obj);
}
//static void copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表中,会覆盖目标列表中的对应数据元素。
//注意：目标集合的元素个数 >= 源集合的元素个数，否则java.lang.IndexOutOfBoundsException: Source does not fit in dest
ArrayList list2=new ArrayList();
list2.add(234);
list2.add(547);
list2.add(13);
list2.add(464);
list2.add(4565);
list2.add(6579823);
Collections.copy(list2, list1);
for(Object obj:list2){
System.out.println(“list2==”+obj);
}
}
}

小方f

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合框架

8.集合框架8.1集合框架的体系结构集合–集中合并数据----文件夹是一个集合的表现 --统一管理/处理数据框架–jdk提供操作类库集合框架–jdk提供的对集中合并数据进行统一管理/处理的开发类库。交由集合统一管理/处理的数据有两种表现形式：单列数据【独立的一个数据–数字，字符串,…】 100 ,”hello”键值对数据【一个数据是由键和建对应的值组成】书的目录就是一种典型的键值对数据8.2 Conllection与MapJdk提供的处理单列数据
复制链接

扫一扫