java中的集合框架

导读:本篇文章讲解 java中的集合框架,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com

 一、集合框架

        集合框架—java做好的用来管理乱七八糟的一堆数据的java类库
        集合—-【乱七八糟的一堆】
        框架—–做好的java类库

Java中的集合框架总体被分为2个大部分
第一个大部分是用来处理单列数据的集合,最大的接口时Collection接口
        例如:100   “Holle”
 Collection接口之下有两个子接口:List接口 / Set接口
 List接口时用来处理有序的单列数据,可以有重复的数据。
        ArrrayList类:
                1.处理有序的单列数据,可以有重复的数据。
                2.添加的元素会自动扩展
                3.动态数据结构,查询数据快,添加删除数据慢
        LinkedList类:
                1.处理有序的单列数据,可以有重复的数据。
                2.添加数据会自动扩展
                3.双向链表结构,查询数据慢,添加删除数据快。
Set接口时用来处理无序的单列数据,没有重复的元素,重复的元素算第一个。
        HashSet类
                1.处理无序的单列数据,没有重复的元素,重复的元素算第一个。
                LinkedHashSet类
                        用来处理无序的单列数据,没有重复的元素,重复的元素算第一个。

第二个部分是用来处理键值对数据的集合,最大的接口是Map接口
       
例如:name[键]=zhangsan[值]    书的目录就是典型的键值对
        HashMap类
                1.用来处理键值对数据的集合
                2.允许有null键–null   值–null】
        Hashtable类
               1.用来处理键值对数据的集合
                2.不允许有null
        ConcurentHashMap类
                支持检索完全并发性和更新的高预算并发性的哈希表

二、关于List接口下的常用类

 1.ArrayList类
        用来处理有序的单列数据,可以有重复的元素。
        添加的元素会自动扩展
        动态数据结构,查询速度快,添加删除速度慢
构造方法:
        ArrayList()构造一个初始量为10的空列表
        ArrayList(Collection  c)通过实现Collection接口的子类/子接口对象创建一个列表
        ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
实例方法:
        boolean   add(Object  o)将指定的元素追加到此列表的末尾
        boolean   container(Object  o)如果此列表包含指定的元素,则返回true。
        Object     get(int  index)返回此列表中指定位置的元素。
        int    lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引,如果没有这个元素返回-1
         int    IndexOf(Object o)返回此列表中指定元素的第一次出现的索引
        Object     remove(int index) 删除该列表中指定位置的元素。 
        boolean    remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。 
        Object     set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。 
        int      size() 返回此列表中的元素数。 
        boolean    isEmpty() 如果此列表不包含元素,则返回 true 。
        void      clear() 从列表中删除所有元素。 
        Iterator<E>    iterator() 以正确的顺序返回该列表中的元素的迭代器。 

例如:

package com.wangxing.test1;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest {

	public static void main(String[] args) {
		// 1.ArrayList类
		// 构造方法:
		// ArrayList() 构造一个初始容量为10的空列表。
		ArrayList list1 = new ArrayList();
		// ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
		ArrayList list2 = new ArrayList(list1);// 可以将其他的集合类转换成
		// ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
		ArrayList list3 = new ArrayList(22);

		// 实例方法:
		// boolean add(Object o) 将指定的元素追加到此列表的末尾。
		list1.add("fxt");
		list1.add(1001);
		list1.add(22);
		list1.add("西安");
		list1.add("fxt");
		// boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
		boolean flag = list1.contains("fxt");
		if (flag) {
			System.out.println("找到了这个元素");
		} else {
			System.out.println("没有找到");
		}
		// Object get(int index) 返回此列表中指定位置的元素。
		System.out.println(list1.get(1));// 1001
		// int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
		System.out.println(list1.indexOf("fxt"));// 1
		// int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
		System.out.println(list1.lastIndexOf("fxt"));// 4
		// Object  remove(int index) 删除该列表中指定位置的元素。
		// System.out.println("删除之前元素的个数:"+list1.size());//5
		// list1.remove(4);
		// System.out.println("删除元素之后的个数:"+list1.size());//4
		// boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
		//System.out.println("删除之前元素的个数:"+list1.size());//5
		//Integer int1=new Integer(22);
		//System.out.println(list1.remove(int1)); //true
		//System.out.println("删除元素之后的个数:"+list1.size());//4
		// Object  set(int index, Object  element) 用指定的元素替换此列表中指定 位置的元素。
		list1.set(4, "web");
		System.out.println(list1.get(4));//web
		 // int size() 返回此列表中的元素数。
		// boolean isEmpty() 如果此列表不包含元素,则返回 true 。
		System.out.println(list1.isEmpty());//false
		// void clear() 从列表中删除所有元素。
		//list1.clear();
		//System.out.println(list1.size());//0
		
		//有序集合遍历
		//1.for循环
		for(int i=0;i<list1.size();i++){
			System.out.println("普通for循环--"+list1.get(i));
		}
		//1.增强的for循环
		for(Object value :list1){
			System.out.println("增强for循环--"+value);
		}
		//Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
		Iterator it=list1.iterator();
		while(it.hasNext()){
			Object value=it.next();
			System.out.println("Iterator<E>迭代器--"+value);
		}
	}
}

2.LinkedList类
        
1.用来处理有序的单列数据,可以有重复的元素。
        2.添加的元素会自动扩展。
        3.双向链表结构,查询速度慢,添加删除速度快
构造方法:
        LinkedList() 构造一个空列表。 
        LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表
实例方法:
        boolean    add(Object o) 将指定的元素追加到此列表的末尾。 
        boolean    contains(Object o) 如果此列表包含指定的元素,则返回 true 。 
        Object     get(int index) 返回此列表中指定位置的元素。 
        int    indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
        int    lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。 
        Object     remove(int index) 删除该列表中指定位置的元素。 
        boolean    remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。 
        Object     set(int index, Object  element) 用指定的元素替换此列表中指定 位置的元素。 
        int    size() 返回此列表中的元素数。 
        boolean    isEmpty() 如果此列表不包含元素,则返回 true 。
        void    clear() 从列表中删除所有元素。 
        Iterator<E>    iterator() 以正确的顺序返回该列表中的元素的迭代器。
        多出一组对第一个元素和最后一个元素的操作方法
        void    addFirst(Object e) 在该列表开头插入指定的元素。 
        void    addLast(Object  e) 将指定的元素追加到此列表的末尾。 
        Object     getFirst() 返回此列表中的第一个元素。 
        Object     getLast() 返回此列表中的最后一个元素。
        Object     removeFirst() 从此列表中删除并返回第一个元素。
        Object     removeLast() 从此列表中删除并返回最后一个元素。
为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法?
        因为ArrayList是动态数组结构,他在查找第一个元素和最后一个元素的时很麻烦,而 LinkedList采用的是双向链表结构,这种结构在查找第一个元素和最后一个元素的时候是最快的 。
        就像一列火车我们眼前驶过,我们可能不知道这列火车由几节车厢组成,但是我们一定会在第一时间看清第一节与最后一节车厢位置。

例如:

package com.wangxing.test1;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest {
	public static void main(String[] args) {

		// 2.LinkedList类
		// 1.用来处理有序的单列数据,可以有重复的元素。
		// 2.添加的元素会自动扩展。
		// 3.双向链表结构,查询速度慢,添加删除速度快
		// 构造方法:
		// LinkedList() 构造一个空列表。
		LinkedList list1 = new LinkedList();
		// LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表
		LinkedList list2 = new LinkedList(list1);

		// 实例方法:
		// boolean add(Object o) 将指定的元素追加到此列表的末尾。
		list1.add("fxt");
		list1.add(1001);
		list1.add(22);
		list1.add("西安");
		list1.add("fxt");
		// boolean contains(Object o) 如果此列表包含指定的元素,则返回 true 。
		boolean flag = list1.contains("fxt");
		if (flag) {
			System.out.println("找到了这个元素");
		} else {
			System.out.println("没有找到");
		}
		// Object get(int index) 返回此列表中指定位置的元素。
		System.out.println(list1.get(1));// 1001
		// int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
		System.out.println(list1.indexOf("fxt"));// 1
		// int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。
		System.out.println(list1.lastIndexOf("fxt"));// 4
		// Object  remove(int index) 删除该列表中指定位置的元素。
		// System.out.println("删除之前元素的个数:"+list1.size());//5
		// list1.remove(4);
		// System.out.println("删除元素之后的个数:"+list1.size());//4
		// boolean remove(Object o) 从列表中删除指定元素的第一个出现(如果存在)。
		// System.out.println("删除之前元素的个数:"+list1.size());//5
		// list1.remove("fxt");
		// System.out.println("删除元素之后的个数:"+list1.size());//4
		// Object  set(int index, Object  element) 用指定的元素替换此列表中指定 位置的元素。
		list1.set(4, "web");
		System.out.println(list1.get(4));// web
		// int size() 返回此列表中的元素数。
		// boolean isEmpty() 如果此列表不包含元素,则返回 true 。
		System.out.println(list1.isEmpty());// false
		// void clear() 从列表中删除所有元素。
		// list1.clear();
		// System.out.println(list1.size());//0
		// 有序集合遍历
		// 1.for循环
		for (int i = 0; i < list1.size(); i++) {
			System.out.println("普通for循环--" + list1.get(i));
		}
		// 1.增强的for循环
		for (Object value : list1) {
			System.out.println("增强for循环--" + value);
		}
		// Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
		Iterator it = list1.iterator();
		while (it.hasNext()) {
			Object value = it.next();
			System.out.println("Iterator<E>迭代器--" + value);
		}
		//多出一组对第一个元素和最后一个元素的操作方法
		//void	addFirst(Object e) 在该列表开头插入指定的元素。
		list1.addFirst("开头");
		//void	addLast(Object  e) 将指定的元素追加到此列表的末尾。 
		list1.addLast("末尾");
		//Object 	getFirst() 返回此列表中的第一个元素。
		list1.getFirst();
		//Object 	getLast() 返回此列表中的最后一个元素。
		list1.getLast();
		//Object 	removeFirst() 从此列表中删除并返回第一个元素。
		list1.removeFirst();
		//Object 	removeLast() 从此列表中删除并返回最后一个元素。 
		list1.removeLast();
	}
}

为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法?
        因为ArrayList是动态数组结构,他在查找第一个元素和最后一个元素的时很麻烦,而LinkedList采用的是双向链表结构,这种结构在查找第一个元素和最后一个元素的时候是最快的 。
        就像一列火车我们眼前驶过,我们可能不知道这列火车由几节车厢组成,但是我们一定会在第一时间看清第一节与最后一节车厢位置。

三、.关于Set接口的常用类 

1.HashSet类
        
用来处理无序的单列数据,没有重复的元素,重复的元素算一个。
构造方法:
    HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。 
    HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。 
    HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。 
    HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子。 
实例方法
    boolean    add(Object e) 将指定的元素添加到此集合(如果尚未存在)。 
    void    clear() 从此集合中删除所有元素。 
    boolean    contains(Object o) 如果此集合包含指定的元素,则返回 true 。 
    boolean    isEmpty() 如果此集合不包含元素,则返回 true 。 
    Iterator    iterator() 返回此集合中元素的迭代器。 
    boolean    remove(Object o) 如果存在,则从该集合中删除指定的元素。 
    int    size() 返回此集合中的元素数(其基数)。

例如:

package com.wangxing.test2;
import java.util.HashSet;
import java.util.Iterator;

public class HashSetTets {
	public static void main(String[] args) {
		// 1.HashSet类
		// 用来处理无序的单列数据,没有重复的元素,重复的元素算一个。
		// 构造方法:
		// HashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
		HashSet set1= new HashSet();
		// HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
		HashSet set2= new HashSet(set1);
		// HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。
		HashSet set3= new HashSet(23);
		// HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子。
		HashSet set4= new HashSet(20,0.5f);
		HashSet set5= new HashSet(20,0.6f);
		//实例方法
		//boolean	add(Object e) 将指定的元素添加到此集合(如果尚未存在)。 
		set1.add("fxt");
		set1.add(1001);
		set1.add("西安");
		set1.add("fxt");
		System.out.println(set1.size());//3,重复的算一个
		//void	clear() 从此集合中删除所有元素。 
		//set1.clear();
		//System.out.println(set1.size()); //0
		//boolean	contains(Object o) 如果此集合包含指定的元素,则返回 true 。 
		System.out.println(set1.contains("fxt"));//true
		//boolean	isEmpty() 如果此集合不包含元素,则返回 true 。 
		System.out.println(set2.isEmpty());//true 
		
		//遍历无序单列数据
		//增强for循环
		for(Object value :set1){
			System.out.println("增强for循环---"+value);
		}
		//Iterator<E>	iterator() 返回此集合中元素的迭代器。 
		Iterator it=set1.iterator();
		if(it.hasNext()){
			Object value= it.next();
			System.out.println("iterator---"+value);
		}
		//boolean	remove(Object o) 如果存在,则从该集合中删除指定的元素。
		set1.remove("fxt");
		System.out.println(set1.size());//2
		//int	size() 返回此集合中的元素数(其基数)。
	}
}

2.LinkedHashSet类
     
   LinkedHashSet类是HashSet类的子类
构造方法:
    LinkedHashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。 
    LinkedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。 
    LinkedHashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。 
    LinkedHashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子。
实例方法
    boolean    add(Object e) 将指定的元素添加到此集合(如果尚未存在)。 
    void    clear() 从此集合中删除所有元素。 
    boolean    contains(Object o) 如果此集合包含指定的元素,则返回 true 。 
    boolean    isEmpty() 如果此集合不包含元素,则返回 true 。 
    Iterator    iterator() 返回此集合中元素的迭代器。 
    boolean    remove(Object o) 如果存在,则从该集合中删除指定的元素。 
    int    size() 返回此集合中的元素数(其基数)。

例如:

package com.wangxing.test2;

import java.util.Iterator;
import java.util.LinkedHashSet;

public class LinkedHashSetTest {
	public static void main(String args[]) {
		// LinkedHashSet类
		// LinkedHashSet类是HashSet类的子类
		// 构造方法:
		// LikedHashSet() 构造一个新的空集合; 默认初始容量(16)和负载因子(0.75)。
		LinkedHashSet set1= new LinkedHashSet();
		// LikedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
		LinkedHashSet set2= new LinkedHashSet(set1);
		// LikedHashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子(0.75)。
		LinkedHashSet set3= new LinkedHashSet(26);
		// LikedHashSet(int initialCapacity, float loadFactor)
		// 具有指定的初始容量和指定的负载因子。
		LinkedHashSet set4= new LinkedHashSet(26,0.5f);
		//实例方法
		//boolean  add(Object e) 将指定的元素添加到此集合(如果尚未存在)。 
		set1.add("fxt");
		set1.add(1001);
		set1.add(true);
		set1.add(12.5);
		//void	clear() 从此集合中删除所有元素。 
		//set1.clear();
		//System.out.println(set1.size());//0
		//boolean	contains(Object o) 如果此集合包含指定的元素,则返回 true 。 
		System.out.println(set1.contains(1001));//true
		//boolean	isEmpty() 如果此集合不包含元素,则返回 true 。 
		System.out.println(set1.isEmpty());//false
		//boolean	remove(Object o) 如果存在,则从该集合中删除指定的元素。 
		//set1.remove(true);
		//Iterator	iterator() 返回此集合中元素的迭代器。 
		Iterator it = set1.iterator();
		while (it.hasNext()) {
			Object value = it.next();
			System.out.println("Iterator<E>迭代器--" + value);
		}
		//int	size() 返回此集合中的元素数(其基数)。
		//System.out.println(set1.size());
	}
}

Collection接口与Map接口的区别?
        1.Collection接口处理单列数据的集合,Map接口处理键值对数据的集合
List接口与Set接口的区别?
        1.list接口可以有重复的元素,set接口不能有重复的元素
ArrayList类与LinkedList类的区别?
        1.ArrayList类是动态数据结构,查询快,删除添加元素慢
           LinkedList类是双向链表结构,查询速度慢,添加删除快
LinkedHashSet与HashSet区别?
        1.LinkedHashSet类是HashSet类的子类
        2.LinkedHashSet中,保留插入顺序,这意味着元素的插入顺序必须与元素的检索顺序相同。
            HashSet插入中,不保留顺序,这意味着元素的插入顺序不需要与元素的检索顺序相同。

四、 关于Map接口的常用类

        Map接口用来处理键值对数据的集合

1.HashMap类
        1.允许null的值和null键
        2.数据保存是无序的
        3.重复的键被算作是一个数据。
构造方法:
    HashMap() 构造一个空的 HashMap ,默认初始容量(16)和默认负载系数(0.75)。 
    HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子(0.75)。 
    HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负                            载因子。 
    HashMap(Map m) 构造一个新的 HashMap与指定的相同的映射 Map 。 
实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set<Map.Entry<K,V>>    entrySet() 得到集合中所有的键值对数据Set集合中

例如:

package com.wangxing.test3;

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

public class HashMapTest {
	public static void main(String[] args) {

		// 1.HashMap类
		// 1.允许null的值和null键
		// 2.数据保存是无序的
		// 3.重复的键被算作是一个数据。
		// 构造方法:
		// HashMap() 构造一个空的 HashMap ,默认初始容量(16)和默认负载系数(0.75)。
		HashMap list1 = new HashMap();
		// HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子(0.75)。
		HashMap list2 = new HashMap(23);
		// HashMap(int initialCapacity, float loadFactor)
		// 构造一个空的HashMap具有指定的初始容量和负 载因子。
		HashMap list3 = new HashMap(23, 0.5f);
		// HashMap(Map m) 构造一个新的 HashMap与指定的相同的映射
		HashMap list4 = new HashMap(list1);

		// 实例方法:
		// Object put(Object key, Object value) 向集合中添加键值对数据
		list1.put("id", 1001);
		list1.put(true, "女");
		list1.put("姓名", "fxt");
		list1.put("身高", 168.5);
		// boolean containsKey(Object key) 判断集合中是否包含指定的键
		System.out.println(list1.containsKey(true));//true
		// boolean containsValue(Object value) 判断集合中是否包含指定的值
		System.out.println(list1.containsValue(1002));//flase
		// Object  get(Object key) 根据指定的键得到该键对应的值
		System.out.println(list1.get("id"));//1001
		// boolean isEmpty() 判断集合是否为空。
		System.out.println(list1.isEmpty());//false
		// int size() 得到集合中键值对元素的个数
		System.out.println(list1.size());//4
		// Set keySet() 得到集合中所有的键保存到Set集合中
		Set setList1= list1.keySet();
		for(Object key :setList1){
			System.out.println("HashMap中的键存储在set无序单列数据中取出的值:"+key);
		}
		// Collection values() 得到集合中所有的值保存到Collection集合中
		Collection collectionList =list1.values();
		for(Object value:collectionList){
			System.out.println("HashMap中的键存储在Collection集合中取出的值:"+value);
		}
		// Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
		Set<Map.Entry<Object, Object>> set1= list1.entrySet();
		for(Map.Entry<Object,Object> entry:set1){
			System.out.println("key:"+entry.getKey()+"\t"+"value:"+entry.getValue());
		}
		// V remove(Object key) 根基指定的键删除对应的键值对数据值
		list1.remove(true);
		System.out.println(list1.size());//3
		// void clear() 清空集合。
		list1.clear();
		System.out.println(list1.size());//0
		
	}
}

java中的集合框架

 2.Hashtable类
        1.数据保存是无序的
        2.不能有null键/null值
        3.用作键的对象必须实现hashCode方法和equals方法。 
        4.重复的键被算作是一个数据。
        5.线程安全
构造方法:
    Hashtable() 构造一个新的,空的散列表,默认初始容量(11)和负载因子(0.75)。 
    Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75 
    Hashtable(int initialCapacity, float loadFactor) 构造一个新的,空的哈希表,具有指定的初始                容量和指定的负载因子。 
    Hashtable(Map t) 构造一个与给定地图相同的映射的新哈希表。
实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set<Map.Entry<K,V>>    entrySet() 得到集合中所有的键值对数据Set集合中
    Enumeration<K>    keys() 返回此散列表中键的枚举。 
    Enumeration<V>    elements() 返回此散列表中值的枚举。 

例如:

package com.wangxing.test3;

import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashtableTest {
	public static void main(String args[]) {
		// 2.Hashtable类
		// 1.数据保存是无序的
		// 2.不能有null键/null值
		// 3.用作键的对象必须实现hashCode方法和equals方法。
		// 4.重复的键被算作是一个数据。
		// 5.线程安全
		// 构造方法:
		// Hashtable() 构造一个新的,空的散列表,默认初始容量(11)和负载因子(0.75)。
		Hashtable list1=new Hashtable();
		// Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75
		Hashtable list2=new Hashtable(20);
		// Hashtable(int initialCapacity, float loadFactor)构造一个新的,空的哈希表,具有指定的初始容量和指定的负载因子。
		Hashtable list3=new Hashtable(20,0.75f);
		// Hashtable(Map t) 构造一个与给定map相同的映射的新哈希表。
		Hashtable list4=new Hashtable(list1);
		// 实例方法:
		// Object put(Object key, Object value) 向集合中添加键值对数据
		list1.put("id", 1001);
		list1.put(true, "女");
		list1.put("姓名", "fxt");
		list1.put("身高", 168.8);
		// boolean containsKey(Object key) 判断集合中是否包含指定的键
		System.out.println(list1.containsKey("id")); //true
		// boolean containsValue(Object value) 判断集合中是否包含指定的值
		System.out.println(list1.containsKey(1001)); //true
		// Object  get(Object key) 根据指定的键得到该键对应的值
		System.out.println(list1.get("id"));//1001
		// boolean isEmpty() 判断集合是否为空。
		System.out.println(list1.size());//4
		// int size() 得到集合中键值对元素的个数
		System.out.println(list1.isEmpty());
		// Set keySet() 得到集合中所有的键保存到Set集合中
		Set set1=list1.keySet();
		for(Object key :set1){
			System.out.println("Hashtable中的键存储在set无序单列数据中取出的值:"+key);
		}
		Iterator it=set1.iterator();
		while(it.hasNext()){
			Object key=it.next();
			System.out.println("Hashtable中的键存储在set无序单列数据中利用迭代器取出的值:"+key);	
		}
		// Collection values() 得到集合中所有的值保存到Collection集合中
		Collection collectionList =list1.values();
		Iterator it2=collectionList.iterator();
		while(it2.hasNext()){
			Object value=it2.next();
			System.out.println("Hashtable中的键存储在Collection集合中利用迭代器取出的值:"+value);	
		}
		// Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
		Set<Map.Entry<Object,Object>>set2= list1.entrySet();
		for( Map.Entry<Object,Object> entry:set2){
			System.out.println("key:"+entry.getKey()+"\t"+"value:"+entry.getValue());
		}
		// Enumeration<K> keys() 返回此散列表中键的枚举。
		// Enumeration<V> elements() 返回此散列表中值的枚举。
		// V remove(Object key) 根基指定的键删除对应的键值对数据值
		list1.remove("id");
		System.out.println(list1.size());//3
		// void clear() 清空集合
		list1.clear();
		System.out.println(list1.size());//0
	}
}

java中的集合框架

 3.TreeMap类
        红黑树基于NavigableMap实现【有序】
        1.按照键的字母顺序排列
        2.键不能为null
        3.重复的键被算作是一个数据。
        4.非线程安全
构造方法
    TreeMap() 使用其键的自然排序构造一个新的空树状图。 
    TreeMap(Map<? extends K,? extends V> m) 构造一个新的树状图,其中包含与给定地图相同的映射,根 据其键的自然顺序进行排序 。
实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set<Map.Entry<K,V>>    entrySet() 得到集合中所有的键值对数据Set集合中

例如:

package com.wangxing.test3;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapTest {
	public static void main(String args[]) {
		// 3.TreeMap类--红黑树基于NavigableMap实现【有序】
		// 1.按照键的字母顺序排列
		// 2.键不能为null,不能为true
		// 3.重复的键被算作是一个数据。
		// 4.非线程安全
		// 构造方法
		// TreeMap() 使用其键的自然排序构造一个新的空树状图。
		TreeMap list1 = new TreeMap();
		// TreeMap(Map<? extends K,? extends V> m)
		// 构造一个新的树状图,其中包含与给定地图相同的映射,根据其键的自然顺序进行排序 。

		// 实例方法:
		// Object put(Object key, Object value) 向集合中添加键值对数据
		list1.put("id", 1001);
		list1.put("姓名", "fxt");
		list1.put("身高", 168.5);
		list1.put("nv",true);
		// boolean containsKey(Object key) 判断集合中是否包含指定的键
		System.out.println(list1.containsKey("id"));//true
		// boolean containsValue(Object value) 判断集合中是否包含指定的值
		System.out.println(list1.containsValue(1002));//flase
		// Object  get(Object key) 根据指定的键得到该键对应的值
		System.out.println(list1.get("id"));//1001
		// boolean isEmpty() 判断集合是否为空。
		System.out.println(list1.isEmpty());//false
		// int size() 得到集合中键值对元素的个数
		System.out.println(list1.size());//4
		// Set keySet() 得到集合中所有的键保存到Set集合中
		Set setList1= list1.keySet();
		for(Object key :setList1){
			System.out.println("HashMap中的键存储在set无序单列数据中取出的值:"+key);
		}
		// Collection values() 得到集合中所有的值保存到Collection集合中
		Collection collectionList =list1.values();
		for(Object value:collectionList){
			System.out.println("HashMap中的键存储在Collection集合中取出的值:"+value);
		}
		// Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
		Set<Map.Entry<Object, Object>> set1= list1.entrySet();
		for(Map.Entry<Object,Object> entry:set1){
			System.out.println("key:"+entry.getKey()+"\t"+"value:"+entry.getValue());
		}
		// V remove(Object key) 根基指定的键删除对应的键值对数据值
		list1.remove("nv");
		System.out.println(list1.size());//3
		// void clear() 清空集合。
		list1.clear();
		System.out.println(list1.size());//0
	}
}

java中的集合框架
4.ConcurrentHashMap类与HashMap相似
        ConcurrentHashMap类线程安全支出检索是的高并发处理。
        如果需要线程安全的并发实现,那么建议使用ConcurrentHashMap代替Hashtable。

HashMap类与Hashtable类与TreeMap类与ConcurrentHashMap类区别?
1.HashMap类能有null键/null值,Hashtable类不能有null键/null值,TreeMap类的键不能为空和true
2.HashMap类和Hashtable类无序,TreeMap类有序的按照字母顺序排列
3.Hashtable类线程安全,TreeMap类非线程安全,4.ConcurrentHashMap类实现线程安全的并发

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/79835.html

(0)

相关推荐

半码博客——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!