1.集合框架
集合框架---java做好的用来管理乱七八糟的一堆数据的java类库
集合---乱七八糟的一堆
框架---做好的java类库
java中的集合框架子总体被分为两大部分
1.第一大部分用来处理单列数据的集合，最大的接口是Collection接口
Collection接口之下有两个子接口：List接口/Set接口
List接---是来处理有序的单列数据，可以有重复的元素
ArrayList类
1.用来处理有序的单列数据，可以有重复的元素
2.添加元素会自动扩展
3.动态数组结构，查询速度快，添加删除速度慢
LinkedList类
1.用来处理有序的单列数据，可以重复元素。
2.添加元素会自动扩展
3.双向链表结构，查询速度慢，添加删除速度快
Set接口---用来梳理无序的单列数据，没有重复的元素，重复的元素算一个
LinkedHashSet类
用来处理无序的单列数据，没有重复的元素，重复元素算一个
2.第二大部分是用来处理键值对数据的集合，最大接口是Map接口
HashMap类
1.用来处理键值对数据集合
2.允许有null【键-null 值-null】
Hashtable类
1.用来处理键值对数据集合
2.不允许有null
ConcurrentHashMap类
支持检索的完全并发性和更新的高预期并发性的哈希表
2.关于List接口下的常用类
1. ArrayList类
1.用来处理有序的单列数据，可以有重复的元素。
2.添加的元素会自动扩展。
3.动态数组结构，查询速度快，添加删除速度慢
1.构造方法：
ArrayList() 构造一个初始容量为10的空列表。
ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
2.实例方法:
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()---返回此列表中的元素数
bolean isEmpty()---如果此列表不包含元素，则返回true
void clear()---清除列表中的所有元素
Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
例如：
package com.object.test1;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class TestArrayList {
public static void main(String[] args) {
//ArrayList() 构造一个初始容量为10的空列表。
ArrayList arr=new ArrayList();
List arry=new ArrayList();
//ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
ArrayList arr2=new ArrayList(arry);
List arry2=new ArrayList();
//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
ArrayList arr3=new ArrayList(30);
List arry3=new ArrayList();
//boolean add(Object o) 将指定的元素追加到此列表的末尾。
arr.add("张三");
arr.add(1001);
arr.add(23);
arr.add(true);
arr.add("张三");
//size() 返回此列表中的元素数。
System.out.println(arr.size());
//boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。
System.out.println(arr.contains("张三"));
//Object get(int index) 返回此列表中指定位置的元素。
System.out.println(arr.get(2));
//int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(arr.indexOf("张三"));
//int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(arr.lastIndexOf("张三"));
//Object remove(int index) 删除该列表中指定位置的元素。
//System.out.println(arr.remove(4));
//System.out.println(arr.size());
//boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
//System.out.println(arr.remove("张三"));
//System.out.println(arr.size());
//set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
arr.set(4, "李四");
System.out.println(arr.get(4));
//boolean isEmpty() 如果此列表不包含元素，则返回 true 。
System.out.println(arr.isEmpty());
//void clear() 从列表中删除所有元素。
//arr.clear();
//System.out.println(arr.size());
//Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
//for循环
for(int i=0;i<arr.size();i++){
System.out.println("for循环=="+arr.get(i));
}
//增强的for循环
for(Object objec:arr){
System.out.println("增强的for循环=="+objec);
}
Iterator list=arr.iterator();
while(list.hasNext()){
Object obj=list.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}
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()---返回此列表中的元素数
bolean isEmpty()---如果此列表不包含元素，则返回true
ArrayList比LinkedList多出一组对列表第一个元素和最后一个元素的操作方法，ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而LinkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的
就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。
void clear()---清除列表中的所有元素
void addFirst(Object e)---将指定元素追加到此列表的开头
void addLast(Object e)---将指定元素追加到此列表的末尾
Object getFirst()---返回此列表的第一个元素
Object getLast()---返回此列表的最后一个元素
Object removeFirst() 从此列表中删除并返回第一个元素
Object removeLast() 从此列表中删除并返回第一个元素
例如：
package com.object.test1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class TestLinkList {
public static void main(String[] args) {
//LinkedList() 构造一个空列表。
LinkedList lin=new LinkedList();
List lis11=new LinkedList();
//LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表
ArrayList arr=new ArrayList();
LinkedList lin2=new LinkedList(arr);
//boolean add(Object o) 将指定的元素追加到此列表的末尾。
lin.add("张三");
lin.add(1001);
lin.add(23);
lin.add(true);
lin.add("张三");
//size() 返回此列表中的元素数。
System.out.println(lin.size());
//boolean contains(Object o) 如果此列表包含指定的元素，则返回 true 。
System.out.println(lin.contains("张三"));
//Object get(int index) 返回此列表中指定位置的元素。
System.out.println(lin.get(2));
//int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(lin.indexOf("张三"));
//int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
System.out.println(lin.lastIndexOf("张三"));
//Object remove(int index) 删除该列表中指定位置的元素。
//System.out.println(lin.remove(4));
//System.out.println(lin.size());
//boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
//System.out.println(lin.remove("张三"));
//System.out.println(lin.size());
//set(int index, Object element) 用指定的元素替换此列表中指定位置的元素。
lin.set(4, "李四");
System.out.println(lin.get(4));
//boolean isEmpty() 如果此列表不包含元素，则返回 true 。
System.out.println(lin.isEmpty());
//void clear() 从列表中删除所有元素。
//lin.clear();
//System.out.println(lin.size());
//void addFirst(Object e) 在该列表开头插入指定的元素。
lin.addFirst("lisi");
//Object getFirst() 返回此列表中的第一个元素。
System.out.println(lin.getFirst());
//Object removeFirst() 从此列表中删除并返回第一个元素。
lin.removeFirst();
System.out.println(lin.getFirst());
//void addLast(Object e) 将指定的元素追加到此列表的末尾。
lin.addLast("王五");
//Object getLast() 返回此列表中的最后一个元素。
System.out.println(lin.getLast());
//Object removeLast() 从此列表中删除并返回最后一个元素。
lin.removeLast();
System.out.println(lin.getLast());
//for循环
for(int i=0;i<lin.size();i++){
System.out.println("for循环=="+lin.get(i));
}
//增强的for循环
for(Object obj:lin){
System.out.println("for循环=="+obj);
}
//Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it=lin.iterator();
while(it.hasNext()){
Object objc=it.next();
System.out.println("Iterator迭代器=="+objc);
}
}
}
3.关于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.object.test1;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestHashSet {
public static void main(String[] args) {
//HashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。
HashSet hast=new HashSet();
Set has1=new HashSet();
//HashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
HashSet hast2=new HashSet(new ArrayList());
Set has2=new HashSet(new ArrayList());
//HashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75)
HashSet hast3=new HashSet(30);
//HashSet(int initialCapacity, float loadFactor) 具有指定的初始容量和指定的负载因子。
HashSet hast4=new HashSet(20,0.5f);
//boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）。
hast.add("张三");
hast.add(18);
hast.add(189.4);
hast.add(true);
hast.add("张三");
//boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
System.out.println(hast.contains("张三"));//true
System.out.println(hast.contains("李四"));//false
System.out.println(hast.size());
//boolean remove(Object o) 如果存在，则从该集合中删除指定的元素。
System.out.println(hast.remove("张三"));
//int size() 返回此集合中的元素数（其基数）。
System.out.println(hast.size());
//boolean isEmpty() 如果此集合不包含元素，则返回 true 。
System.out.println(hast.isEmpty());
//增强的for循环
for(Object objec:hast){
System.out.println("增强的for循环=="+objec);
}
Iterator list=hast.iterator();
while(list.hasNext()){
Object obj=list.next();
System.out.println("Iterator迭代器=="+obj);
}
}
}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.object.test1;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class TestLinkedSet {
public static void main(String[] args) {
// LikedHashSet() 构造一个新的空集合; 默认初始容量（16）和负载因子（0.75）。
LinkedHashSet set1 = new LinkedHashSet();
Set set11 = new LinkedHashSet();
// LikedHashSet(Collection c) 构造一个包含指定集合中的元素的新集合。
LinkedHashSet set2 = new LinkedHashSet(new ArrayList());
Set set122 = new LinkedHashSet(new ArrayList());
// LikedHashSet(int initialCapacity) 构造一个新的空集合; 具有指定的初始容量和默认负载因子（0.75）。
LinkedHashSet set3 = new LinkedHashSet(20);
Set set133 = new LinkedHashSet(20);
// LikedHashSet(int initialCapacity, float loadFactor)
// 具有指定的初始容量和指定的负载因子。
LinkedHashSet set4 = new LinkedHashSet(20, 0.5f);
Set set144 = new LinkedHashSet(20, 0.5f);
// 实例方法
// boolean add(Object e) 将指定的元素添加到此集合（如果尚未存在）。
set1.add("zhangsan");
set1.add(23);
set1.add(168.5);
set1.add(true);
set1.add("zhangsan");
// int size() 返回此集合中的元素数（其基数）。
System.out.println("size=" + set1.size());
// boolean remove(Object o) 如果存在，则从该集合中删除指定的元素。
set1.remove("zhangsan");
System.out.println("size=" + set1.size());
// boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
System.out.println("contains==" + set1.contains("lisi"));
// void clear() 从此集合中删除所有元素。
// set1.clear();
// boolean isEmpty() 如果此集合不包含元素，则返回 true 。
System.out.println("isEmpty==" + set1.isEmpty());
// Iterator iterator() 返回此集合中元素的迭代器。
// 1.增强的for
for (Object obj : set1) {
System.out.println("增强的for---" + obj);
}
// 2.Iterator<E> iterator() 以正确的顺序返回该列表中的元素的迭代器。
Iterator it = set1.iterator();
while (it.hasNext()) {
Object obj = it.next();
System.out.println("Iterator迭代器---" + obj);
}
}
}
4.关于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具有指定的初始容量和负载因子（0.75）。
HashMap(Map m) 构造一个新的 HashMap与指定的相同的映射 Map 。
实例方法：
- boolean put(Object e)---向集合中添加键值对
- void clear()---清空集合
- boolean containsKey(Object key) 判断集合中是否包含指定的键
- boolean containsValue(Object value) 判断集合中是否包含指定的值
- Object get(Object key) 根据指定的键得到该键对应的值
- V remove(Object o)---如果存在，则从该集合中删除指定的元素。
- boolean isEmpty() 判断集合是否为空。
- int size() 得到集合中键值对元素的个数
- Set keySet() 得到集合中所有的键保存到Set集合中
- Collection values() 得到集合中所有的值保存到Collection集合中
- Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
例如：
package com.objet.test2;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestHashMap {
public static void main(String[] args) {
//HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap hasm1=new HashMap();
//HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap hasm2=new HashMap(20);
//HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap hasm3=new HashMap(20,0.8f);
//HashMap(Map m) 构造一个新的 HashMap与指定的相同的映射 Map 。
HashMap hasm4 =new HashMap(hasm1);
//Object put(Object key, Object value) 向集合中添加键值对数据
hasm1.put("id",1001);
hasm1.put("name", "张三");
hasm1.put("age", 23);
hasm1.put(true, 189.1);
hasm1.put("sex", null);
hasm1.put(null, null);
//boolean containsKey(Object key) 判断集合中是否包含指定的键
System.out.println(hasm1.containsKey(true));
//boolean c ontainsValue(Object value) 判断集合中是否包含指定的值
System.out.println(hasm1.containsValue("张三"));
//Object get(Object key) 根据指定的键得到该键对应的值
System.out.println(hasm1.get("age"));
//boolean isEmpty() 判断集合是否为空。
System.out.println(hasm1.isEmpty());
//int size() 得到集合中键值对元素的个数
System.out.println(hasm1.size());
//V remove(Object key) 根基指定的键删除对应的键值对数据值
//hasm1.remove("id");
//System.out.println(hasm1.get("id"));
//Set keySet() 得到集合中所有的键保存到Set集合中
Set list=hasm1.keySet();
for(Object obj:list){
System.out.println("forkey--"+obj);
}
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println("Iteratorkey--"+obj);
}
///Collection values() 得到集合中所有的值保存到Collection集合中
Collection cole2=hasm1.values();
for(Object obj:cole2){
System.out.println("Collectionforkey--"+obj);
}
Iterator it2=cole2.iterator();
while(it2.hasNext()){
Object obj=it2.next();
System.out.println("CollectionIteratorkey--"+obj);
}
//Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
Set<Map.Entry<Object,Object>> getlist=hasm1.entrySet();
for(Map.Entry<Object,Object> obj:getlist){
System.out.println("entrySetfor--"+obj.getKey()+":"+obj.getValue());
}
}
}
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) 构造一个与给定地图相同的映射的新哈希表。
实例方法:
- boolean put(Object e)---向集合中添加键值对
- void clear()---清空集合
- boolean containsKey(Object key) 判断集合中是否包含指定的键
- boolean containsValue(Object value) 判断集合中是否包含指定的值
- Object get(Object key) 根据指定的键得到该键对应的值
- V remove(Object o)---如果存在，则从该集合中删除指定的元素。
- boolean isEmpty() 判断集合是否为空。
- int size() 得到集合中键值对元素的个数
- Set keySet() 得到集合中所有的键保存到Set集合中
- Collection values() 得到集合中所有的值保存到Collection集合中
- Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
- Enumeration<K> keys() 返回此散列表中键的枚举。
- Enumeration<V> elements() 返回此散列表中值的枚举。
例如：
package com.objet.test2;
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestHashtale {
public static void main(String[] args) {
//Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。
Hashtable hasm1=new Hashtable();
//Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75
Hashtable hasm2=new Hashtable(20);
//Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。 。
Hashtable hasm3=new Hashtable(20,0.8f);
//Hashtable(Map t) 构造一个与给定地图相同的映射的新哈希表。
Hashtable hasm4 =new Hashtable(hasm1);
//Object put(Object key, Object value) 向集合中添加键值对数据
hasm1.put("id",1001);
hasm1.put("name", "张三");
hasm1.put("age", 23);
hasm1.put(true, 189.1);
hasm1.put("sex", null);
hasm1.put(null, null);
//boolean containsKey(Object key) 判断集合中是否包含指定的键
System.out.println(hasm1.containsKey(true));
//boolean c ontainsValue(Object value) 判断集合中是否包含指定的值
System.out.println(hasm1.containsValue("张三"));
//Object get(Object key) 根据指定的键得到该键对应的值
System.out.println(hasm1.get("age"));
//boolean isEmpty() 判断集合是否为空。
System.out.println(hasm1.isEmpty());
//int size() 得到集合中键值对元素的个数
System.out.println(hasm1.size());
//V remove(Object key) 根基指定的键删除对应的键值对数据值
//hasm1.remove("id");
//System.out.println(hasm1.get("id"));
//Set keySet() 得到集合中所有的键保存到Set集合中
Set list=hasm1.keySet();
for(Object obj:list){
System.out.println("forkey--"+obj);
}
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println("Iteratorkey--"+obj);
}
///Collection values() 得到集合中所有的值保存到Collection集合中
Collection cole2=hasm1.values();
for(Object obj:cole2){
System.out.println("Collectionforkey--"+obj);
}
Iterator it2=cole2.iterator();
while(it2.hasNext()){
Object obj=it2.next();
System.out.println("CollectionIteratorkey--"+obj);
}
//Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
Set<Map.Entry<Object,Object>> getlist=hasm1.entrySet();
for(Map.Entry<Object,Object> obj:getlist){
System.out.println("entrySetfor--"+obj.getKey()+":"+obj.getValue());
}
//Enumeration<K> keys() 返回此散列表中键的枚举。
//Enumeration<V> elements() 返回此散列表中值的枚举。
}
}
3.TreeMap类--红黑树基于NavigableMap实现【有序】
1.按照键的字母顺序排列
2.键不能为null
3.重复的键被算作一个数据
4.非线程安全
构造方法
TreeMap() 使用其键的自然排序构造一个新的空树状图。
TreeMap(Map<? extends K,? extends V> m) 构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序进行排序 。
实例方法:
- boolean put(Object e)---向集合中添加键值对
- void clear()---清空集合
- boolean containsKey(Object key) 判断集合中是否包含指定的键
- boolean containsValue(Object value) 判断集合中是否包含指定的值
- Object get(Object key) 根据指定的键得到该键对应的值
- V remove(Object o)---如果存在，则从该集合中删除指定的元素。
- boolean isEmpty() 判断集合是否为空。
- int size() 得到集合中键值对元素的个数
- Set keySet() 得到集合中所有的键保存到Set集合中
- Collection values() 得到集合中所有的值保存到Collection集合中
- Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
例如：
package com.objet.test2;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TestTreeMap {
public static void main(String[] args) {
//TreeMap() 使用其键的自然排序构造一个新的空树状图。
TreeMap hasm1=new TreeMap();
//TreeMap(Map<? extends K,? extends V> m) 构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序进行排序 。
//Object put(Object key, Object value) 向集合中添加键值对数据
hasm1.put("id",1001);
hasm1.put("name", "张三");
hasm1.put("age", 23);
hasm1.put("height",187.5);
hasm1.put("sex", null);
//hasm1.put(null, null);
//boolean containsKey(Object key) 判断集合中是否包含指定的键
System.out.println(hasm1.containsKey("id"));
//boolean c ontainsValue(Object value) 判断集合中是否包含指定的值
System.out.println(hasm1.containsValue("张三"));
//Object get(Object key) 根据指定的键得到该键对应的值
System.out.println(hasm1.get("age"));
//boolean isEmpty() 判断集合是否为空。
System.out.println(hasm1.isEmpty());
//int size() 得到集合中键值对元素的个数
System.out.println(hasm1.size());
//V remove(Object key) 根基指定的键删除对应的键值对数据值
//hasm1.remove("id");
//System.out.println(hasm1.get("id"));
//Set keySet() 得到集合中所有的键保存到Set集合中
Set list=hasm1.keySet();
for(Object obj:list){
System.out.println("forkey--"+obj);
}
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println("Iteratorkey--"+obj);
}
///Collection values() 得到集合中所有的值保存到Collection集合中
Collection cole2=hasm1.values();
for(Object obj:cole2){
System.out.println("Collectionforkey--"+obj);
}
Iterator it2=cole2.iterator();
while(it2.hasNext()){
Object obj=it2.next();
System.out.println("CollectionIteratorkey--"+obj);
}
//Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中
Set<Map.Entry<Object,Object>> getlist=hasm1.entrySet();
for(Map.Entry<Object,Object> obj:getlist){
System.out.println("entrySetfor--"+obj.getKey()+":"+obj.getValue());
}
}
}4.ConcurrentHashMap类与HashMap相似
ConcurrentHashMap类线程安全支出检索是的高并发处理。
如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable。
60
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
