——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
Map集合:该集合存储键值对,是双列集合。一对一对往里面存,且要保证键的唯一性。
Map
|--HashTable 底层是哈希表数据结构,不可以存入null键和null值。
用作键的对象必须实现hashCode和equals方法。
该集合是线程同步的。
|--HashMap 底层是哈希表数据结构,允许使用null键和null值 。
该集合是线程不同步的。
|--TreeMap 底层是二叉树结构,线程不同步,可以给Map集合的键值排序。
注意HashTable和HashMap的区别。
TreeMap中用作键的对象,必须实现Compareble接口,覆盖compareTo方法,让对象自身具备可比较性,称为对象的自然排序。也可以构造时,传入指定的比较器,对对象进行排序。
Map集合的共性方法
1.添加
V put(K k,V v)
注意:put方法使用时,如果存的两个数,键值相同,那么后者会覆盖前者,会把前边的值返回。
putAll(Map<? extends K,? extends V>)
2.删除
clear()
remove(Object key)
3.判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4.获取
get(Object key)
size()
Collection<V> valuse()返回此映射中包含的值的 Collection 视图。
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
Set<K> keySet()
返回此映射中包含的键的 Set 视图。
Map集合和Set集合很像,其实,Set底层就是使用了Map集合
重点:Map集合的两种取出方式
1.Set<K> keySet():
将Map中所有的键存入到Set集合。因为Set具备迭代器。
所以可以迭代方式取出所有的键,根据get方法。获取每一个键对应的值。
2.Set<Map.Entry<K,V>> entrySet():
将Map中的映射关系存放在Set集合中,这种关系的类型是Map.Entry。
Map集合取出演示:
public void fun(){
Map<String,String> map=new HashMap<String,String>();
map.put("zhangsan","8");
map.put("lisi","9");
map.put("wangwu","10");
map.put("hehe","20");
//取出方式1
//获取Map集合的所有键的Set集合,keySet();
Set<String> keySet=map.keySet();
//有了Set集合就可以。获取其迭代器
Iterator<String> it=keySet.iterator();
while(it.hasNext())
{
String key=it.next();
//通过键获取值
String value=map.get(key);
System.out.println("name:"+key+", age:"+value);
}
//取出方式2
//将Map集合中的映射关系取出。存入到Set集合中
Set<Map.Entry<String,String>> entrySet=map.entrySet();
Iterator<Map.Entry<String,String>> it=entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String> me=it.next();
String value=me.getValue();
String key=me.getKey();
System.out.println("name:"+key+", age:"+value);
}
}
Map.Entry 其实Entry也是一个接口,它是Map接口中的一个内部接口。
Java为了方便对各种集合的操作提供了专门的操作工具:Collections,Arrays工具类。
Collections是专门对集合进行操作的工具类。
Collections中的常用方法:
1.static <T extends Comparable<? super T>> void sort(List<T> list)
对list进行排序,按自然顺序从小到大排序
static <T> void sort(List<T> list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序
2.static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的自然顺序,返回给定 collection 的最大元素
3.static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表,以获得指定对象。
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜索法搜索指定列表,以获得指定对象。
4.static <T> void fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素
5.static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
6.static void reverse(List<?> list)
反转指定列表中元素的顺序
7.static <T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
8.static void swap(List<?> list, int i, int j)
在指定列表的指定位置处交换元素。
9.<T> Collection<T> synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步(线程安全的)collection。
static <T> List<T> synchronizedList(List<T> list)
返回指定列表支持的同步(线程安全的)列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步(线程安全的)映射。
static <T> Set<T> synchronizedSet(Set<T> s)
返回指定 set 支持的同步(线程安全的)set。
Arrays:用于操作数组的工具类 ,里面都是静态方法.
asList();将数组转换成集合
将数组变成集合有什么好处呢?
可以使用集合的思想和方法来操作数组中的元素。
注意:将数组变成集合,不可以使用集合中的增删方法。
因为数组的长度是固定的。
可以使用:contains、get、indexOf、subList等方法,就是不能使用增删方法,因为数组的长度是固定的
如果增删,那么会发生UnsupportedOperationException。
如果数组中的元素都是对象。那么数组中的元素会直接转换成集合中的元素
如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
eg:
int[] nums={4,5,6,87,3,4};
List<int[]> li=Arrays.asList(nums);
System.out.println(li.size()); //结果为1
Integer[] arr={4,5,6,87,3,5};
List<Integer> list=Arrays.asList(arr);
System.out.println(list.size());//结果为6
对对象进行比较,必须是玩Comparable 或者Compatator
集合变数组:
Collection接口中的toArray()
使用方法: T[] toArray(T[] a)将集合转换为数组。
转换时应当注意:
1.指定类型的数组长度要定义多长呢?
当定义类型的数组长度小于集合的size,那么该方法内部会创建一个新的数组,长度为集合的size,当指定类型的数组长度大于集合的size,就不会创建新数组,而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
2.为什么要将集合变数组呢?
为了限定对元素的操作。不需要进行增删了