一、集合框架
集合框架—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 } }
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 } }
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 } }
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