集合框架（Map）

糖小媎

已于 2022-06-01 19:04:09 修改

阅读量146

点赞数

分类专栏： J2EE 文章标签： java

于 2022-05-19 21:33:26 首次发布

本文链接：https://blog.csdn.net/m0_61148761/article/details/124870102

版权

J2EE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、Map集合的特点

测试集合特点的前题，定义集合并给集合添加数值

Map<String, Object> map = new HashMap<String,Object>();
		
map.put("sc", "11");
map.put("qw", "22");
map.put("we", "33");
map.put("rf", "44");

1、无序

打印结果为：

根据打印结果可以得到Map集合的特点之一是无序性

2、以键值对的形式添加元素（键不能重复【Set】，值可以重复【List】）

在给Map集合添加数据是可以看出Map集合是以键值对的形式添加元素的

2.1如果添加重复值的话：

		map.put("sc", "11");
		map.put("qw", "22");
		map.put("we", "33");
		map.put("rf", "44");
		map.put("rf1", "44");

打印结果为：

2.2如果添加重复键的话：

		map.put("sc", "11");
		map.put("qw", "22");
		map.put("we", "33");
		map.put("rf", "44");
		map.put("rf", "444");

打印结果为：

可以看出键重复的话会发生替代的事件，值可以重复并且可以成功添加进去

3、它没有继承Collection接口

Map集合没有继承Collection接口

二、Map集合的遍历方式

1、获取map集合中的所有key的set集合，再通过key获取value值

		//不常用，基本不用
        Collection<Object> values = map.values();
		for (Object object : values) {
			System.out.println(object);
		}

		Set<String> keySet = map.keySet();
		
		for (String key : keySet) {
//			System.out.println(key);
			//通过键获取对应的值
			Object object = map.get(key);
			System.out.println(key+"="+object);
		}

2、先取出保存所有Entry的Set,再遍历此Set即可 (重要点)

		//常用
        Set<Entry<String, Object>> entrySet = map.entrySet();
		for (Entry<String, Object> entry : entrySet) {
			System.out.println(entry);//所有值
			System.out.println(entry.getKey());//只拿键
			System.out.println(entry.getValue());//只拿值
		}

三、HashMap、TreeMap与HashTable之间的区别

		Map<String, Object> map = new HashMap<String,Object>();

		Map<String, Object> map1 = new TreeMap<String,Object>();
	
		Map<String, Object> map2 = new Hashtable<String,Object>();

HashMap：异步，非安全的。键可以为null,值也可以为null

TreeMap：异步，非安全的。键不可以为null,值可以为null

HashTable：同步既排队，线程安全的。键不可以为null,值也不能为null

打印：

		Set<Entry<String, Object>> entrySet = map.entrySet();
		
		for (Entry<String, Object> entry : entrySet) {
			System.out.println(entry);
		}

四、部分工具类

Collections：工具类，提供一组静态方法操作Collection集合

概念：集合工具类，定义了除了存取以外的集合常用方法。

public static void reverse(List list)//反转集合中元素的顺序
public static void shuffle(List list)//随机重置集合元素的顺序
public static void sort(List list)//升序排序（元素类型必须实现Comparable接口）

public class Demo3 {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList<Integer>();
		list.add(20);
		list.add(10);
		list.add(30);
		list.add(90);
		list.add(70);
		
		//sort排序
		System.out.println(list.toString());
		Collections.sort(list);
		System.out.println(list.toString());
		System.out.println("---------------");
		
		//binarySearch二分查找
		int i=Collections.binarySearch(list, 10);
		System.out.println(i);
		
		//copy复制
		List<Integer> list2=new ArrayList<Integer>();
		for(int i1=0;i1<5;++i1) {
			list2.add(0);
		}
		//该方法要求目标元素容量大于等于源目标
		Collections.copy(list2, list);
		System.out.println(list2.toString());
		
		//reserve反转
		Collections.reverse(list2);
		System.out.println(list2.toString());
		
		//shuffle 打乱
		Collections.shuffle(list2);
		System.out.println(list2.toString());
		
		//补充：list转成数组
		Integer[] arr=list.toArray(new Integer[0]);
		System.out.println(arr.length);
		//补充：数组转成集合 
		String[] nameStrings= {"tang","he","yu"};
		//受限集合，不能添加和删除
		List<String> list3=Arrays.asList(nameStrings);
		System.out.println(list3);
		
		//注：基本类型转成集合时需要修改为包装类
	}
}

Arrays：工具类，提供了一组静态方法操作数组

1、Arrays.sort(Object[] array) //对数组元素进行排序

2、Arrays.asList(T…data) //将数组转换为集合，接收一个可变参数

3、Arrays.toString(Object[] array) //返回数组元素的字符串形式

4、Arrays.deepToString(Object[] array) //返回多维数组元素的字符串形式

5、Arrays.binarySearch(Object[] array, Object key) //使用二分法查找 “有序数组” 内指定元素的索引值

6、Arrays.copyOf(T[] original,int newLength) //拷贝数组，下标从0开始，如果新数组长度超过原数组长度，会用null进行填充

7、Arrays.copyOfRange(T[] original,int from,int to) //拷贝数组，指定起始位置和结束位置，如果新数组长度超过原数组长度，会用null进行填充

8、Arrays.fill(Object[] array,Object obj) //用指定的元素填充整个数组，替换掉原来的元素

9、Arrays.fill(Object[] array,int fromIndex,int toIndex,Object obj)

import java.util.Arrays;
import java.util.List;
public class ArraysTest {
    public static void main(String[] args) {

        int[]  arr1 = {23,4,78,9,36,20};
        //测试Arrays.sort(Object[] array)   对数组元素进行排序
        Arrays.sort(arr1);


        //测试Arrays.toString(Object[] array)  返回数组元素的字符串形式
        System.out.println(Arrays.toString(arr1));


        //测试Arrays.asList(T...data)      将数组转换为集合，接收一个可变参数
        /*
          Arrays.asList(T...data)      将数组转换为集合，接收一个可变参数
          该方法返回的是Arrays内部静态类ArrayList,而不是我们平常使用的集合ArrayList
          该静态类ArrayList没有覆盖父类的add、remove方法，如果直接调用会报异常：
          java.lang.UnsupportedOperationException
         */
        String[] arr2 = {"abc","def","rgh","lef","pyth"};
        List<String> list = Arrays.asList(arr2);
        //list.add("gbn");//java.lang.UnsupportedOperationException
        for (String ele: list ) {
            System.out.println(ele);
        }
        /*
          如果将基本类型的数组作为参数传入，Arrays.asList(T...data)会把整个数组
          当作转换后的List的第一个元素
         */
        int[] arr3 = {345,6,3,2,1};
        List<int[]> list1 = Arrays.asList(arr3);
        System.out.println(list1.size());//长度为：1

        //Arrays.deepToString(Object[] array)  返回多维数组元素的字符串形式
        int[][] arr4 = {{1,2,3},{4,5,6},{7,8,9}};
        System.out.println(Arrays.deepToString(arr4));//[[1, 2, 3], [4, 5, 6], [7, 8, 9]]


        //Arrays.binarySearch(Object[] array, Object key)    使用二分法查找 "有序数组" 内指定元素的索引值
        int[] arr5 = {78,65,2,3,89,12,45};
        Arrays.sort(arr5);
        int index = Arrays.binarySearch(arr5,3);
        System.out.println(index);// 1


        //Arrays.copyOf(T[] original,int newLength)
        // 拷贝数组，下标从0开始，如果新数组长度超过原数组长度，会用null进行填充
        String[] arr6 = {"北京","上海","杭州","成都","深圳","西安","南京"};
        String[] arr6_copy = Arrays.copyOf(arr6,4);
        System.out.println(Arrays.toString(arr6_copy));//[北京, 上海, 杭州, 成都]


        //Arrays.copyOfRange(T[] original,int from,int to)
        // 拷贝数组，指定起始位置和结束位置，如果新数组长度超过原数组长度，会用null进行填充
        String[] arr6_copy2 = Arrays.copyOfRange(arr6,2,4);
        System.out.println(Arrays.toString(arr6_copy2));//[杭州, 成都]

        //Arrays.fill(Object[] array,Object obj)   用指定的元素填充整个数组，替换掉原来的元素
        int[] arr7 = {2,3,4,5,6,7,8};
        Arrays.fill(arr7,1);
        System.out.println(Arrays.toString(arr7));//[1, 1, 1, 1, 1, 1, 1]

        //Arrays.fill(Object[] array,int fromIndex,int toIndex,Object obj)
        //用指定的元素从起始位置到结束位置(左闭右开)填充数组，替换掉数组中原来的元素
        //超出数组的长度会报异常：ava.lang.ArrayIndexOutOfBoundsException
        String[] arr8 = {"北京","上海","杭州","成都","深圳","西安","南京"};
        Arrays.fill(arr8,3,5,"青岛");//[北京, 上海, 杭州, 青岛, 青岛, 西安, 南京]
        //Arrays.fill(arr8,3,8,"青岛");//ava.lang.ArrayIndexOutOfBoundsException
        System.out.println(Arrays.toString(arr8));
    }
}

五、总结

集合框架（Map）就分享到这了，希望能对大家有所帮助！

糖小媎

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合框架（Map）

测试集合特点的前题，定义集合并给集合添加数值1、无序打印结果为：2、以键值对的形式添加元素（键不能重复【Set】，值可以重复【List】）2.1如果添加重复值的话：2.2如果添加重复键的话：可以看出键重复的话会发生替代的事件，值可以重复并且可以成功添加进去3、它没有继承Collection接口1、获取map集合中的所有key的set集合，再通过key获取value值2、先取出保存所有Entry的Set,再遍历此Set即可 (重要点)HashMap：异步，非安全的。键可以为null,值也可以为nullTree
复制链接

扫一扫

专栏目录