Java集合简述(二)


Java集合简述(二)

今天的主角:

  Map集合:Map<K,V>  存储键值对,保证键的唯一性

 一样也是先来看一下Map集合的共性方法:

       1,添加。

              put(K key, V value):向集合添加键值对。

              如果添加时出现相同的键,那么后添加的值会覆盖原有键对应值。 并返回被覆盖的值。

              putAll(Map<?extends K,? extends V> m):添加一组键值对。       

       2,删除。

              clear():从此映射中移除所有映射关系。

              remove(Object key):如果存在一个键的映射关系,则将其从此映射中移除。

       3,判断。

              containsValue(Object value):如果此映射将一个或多个键映射到指定值,则返回true

              containsKey(Object key):如果此映射包含指定键的映射关系,则返回true

              isEmpty():如果此映射未包含键-值映射关系,则返回true

       4,获取。

              get(Object key): 返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回null

              size():返回此映射中的键-值映射关系数。

              values():返回此映射中包含的值的Collection 视图。

       5,两个重要的Map方法:

              Set<Map.Entry<k,v>> entrySet():将map集合中的映射关系存入到了set集合中,

                            而这个关系的数据类型就是:Map.Entry

                            Entry其实就是Map中的一个static内部接口。

                            关系属于Map集合中的一个内部事物。

                            而且该事物在直接访问Map集合中的元素。

              Set<k> keySet():将map中所有的键存入到Set集合。

                            因为set具备迭代器。

                            所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。

         接下来通过代码看一下两个类的使用:

import java.util.*;
class MapDemo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");

		//将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 key = me.getKey();
			String value = me.getValue();
			System.out.println(key+":"+value);
		}

		//先获取map集合的所有键的Set集合,keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合。就可以获取其迭代器。
		Iterator<String> it = keySet.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			//有了键可以通过map集合的get方法获取其对应的值。
			String value  = map.get(key);
			System.out.println("key:"+key+",value:"+value);
		}

	}
}


1.Map有两个重要的子类:

      HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。

    TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。


<span style="font-size:12px;">import java.util.*;
class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		//添加元素,添加元素,如果出现添加时,相同的键。那么后添加的值会覆盖原有键对应值。
		//并put方法会返回被覆盖的值。
		System.out.println("put:"+map.put("01","zhangsan1"));
		System.out.println("put:"+map.put("01","wnagwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");

		
		System.out.println("remove:"+map.remove("02"));//remove函数会返回被删除的值

		System.out.println("get:"+map.get("023"));  //当<span style="font-size:12px;">指定的键不存在<span style="font-size:12px;">时,get方法会返回null</span></span>

		map.put("04",null);
		System.out.println("get:"+map.get("04"));
		//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
<span style="font-size:12px;">                //但是要注意Hash<span style="font-size:12px;">Map可以存储null值</span></span>

<span style="font-size:12px;">                </span> //获取map集合中所有的值。
		Collection<String> coll = map.values();

		System.out.println(coll);
		System.out.println(map);


	}
}
</span>

接下来介绍一下关于集合的工具类:

   Collections工具类:

                   1. sort:排序函数

                    public static <T extends Comparable<? super T>> void sort(List<T> list)

                    List中的对象必须具有比较性

                    public static <T> void sort(List<T> list,Comparator<? super T> c)

                    List中的对象可以没有比较性,但需要传入一个比较器

                2. max:取最大值

                   public static <T extendsObject &Comparable<? super T>> Tmax(Collection<? extends T> coll)

                   根据元素的自然顺序,返回给定 collection 的最大元素。

                   public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)

                   根据指定比较器产生的顺序,返回给定 collection 的最大元素。

                  3.binarySearch:使用二分搜索法搜索指定列表,以获得指定对象的索引

                   public static <T> intbinarySearch(List<? extendsComparable<? super T>> list, T key)

                   public static <T> int binarySearch(List<? extends T> list, T key,Comparator<? super T> c)

               4. fill:使用指定元素替换指定列表中的所有元素。

                   public static <T> void fill(List<? super T> list,T obj)

                  5. replaceAll

                    public static <T> boolean replaceAll(List<T> list, T oldVal,TnewVal)

                   使用另一个值替换列表中出现的所有某一指定值。

                  6. reverse

                   public static void reverse(List<?> list)

                   反转指定列表中元素的顺序。

              7. reverseOrder:

                    public static <T>Comparator<T> reverseOrder(Comparator<T> cmp)

                    返回一个比较器,它强行逆转指定比较器的顺序。

                   如果指定比较器为 null,则此方法等同于reverseOrder()(换句话说,它返回一个比较器,该比较器将强行逆转实现了

                    Comparable 接口的对象 collection 的自然顺序)。

                   8. swap:

                  public static void swap(List<?> list, int i, int j)

                  在指定列表的指定位置处交换元素。(如果指定位置相同,则调用此方法不会更改列表。)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值