栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

J2EE基础(集合框架之Map集合)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

J2EE基础(集合框架之Map集合)

目录

1、map集合的特点

2、map集合的遍历方式

3、常用实现HashMap

4、泛型

5、集合框架工具类


一、map集合的特点

        ①以键值对的形式存放数据:

package com.zq.map;

import java.util.HashMap;
import java.util.Map;

public class Demo1 {
	public static void main(String[] args) {
		Map map=new HashMap<>();
		//增
		// V put(K key, V value);
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);
		System.out.println("普通遍历"+map);
	}
}

        结果:

         ②Map集合增删改:

package com.zq.map;

import java.util.HashMap;
import java.util.Map;

public class Demo1 {
	public static void main(String[] args) {
		Map map=new HashMap<>();
		//增
		// V put(K key, V value);
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);
		System.out.println("增加结果:"+map);
		
		//删除
		Object obj = map.remove("b");
		//打印删除的值
		System.out.println(obj);
		System.out.println("删除后结果"+map);
		
		//修改 也是调用put方法
		map.put("c", 32);
		System.out.println("修改后结果"+map);
	}
}

        结果:


二、map集合的遍历方式(查询):

        ①拿到Key,再拿值:

//1.先拿到map集合中所有key
		Set keyS = map.keySet();
		for (Object key : keyS) {
			System.out.println("键:"+key+";值:"+map.get(key));
		}

        结果:

        ②:拿到映射关系,键值都有了

		//拿到映射关系
		Set> entrySet = map.entrySet();
		for (Entry obj1 : entrySet) {
			System.out.println("键:"+obj1.getKey()+"值:"+obj1.getValue());
		}

        结果:


三、常用实现HashMap         面试题1:统计各字符串出现的次数

       解决思路:
1.做字符串切割,得到一个字符串组
2.接下来遍历,拿到单个字符
3.如果该字符没有出现过,即value值为null,那么设置该字符为KEY(键)初始value值为1
4.如果已经出现过,拿到原来的值+1

        代码展示:

package com.zq.map;

import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

public class Demo2 {
	public static void main(String[] args) {
		String s = "sdjsahdjshjdsdjsdiwjksjakjdsa";

		char[] arr = s.toCharArray();//分割字符串
		HashMap map = new HashMap<>();
		for (char c : arr) {
			Integer value = map.get(c);
			if (value == null) {
				map.put(c, 1);
			} else {
				map.put(c, value + 1);
			}
		}

		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			System.out.println("键:" + entry.getKey() + ":值" + entry.getValue());
		}
	}
}

         结果:

        需求1:按照按首字母排序         分析:可以采用上次的TreeSet方式,我们在Map集合中也可以采用TreeMap

                Map map = new TreeMap<>() ;

          代码展示:

package com.zq.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Demo2 {
	public static void main(String[] args) {
		String s = "sdjsahdjshjdsdjsdiwjksjakjdsa";

		char[] arr = s.toCharArray();
		Map map = new TreeMap<>() ;
		for (char c : arr) {
			Integer value = map.get(c);
			if (value == null) {
				map.put(c, 1);
			} else {
				map.put(c, value + 1);
			}
		}

		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			System.out.println("键:" + entry.getKey() + ":值" + entry.getValue());
		}
	}
}

        结果: 我们成功按照首字母进行了升序排序!

        注意:降序的话就改变一行代码:

                        Map map = new TreeMap<>((x,y) ->y-x);

         结果: 我们成功按照首字母进行了降序排序!

         需求1:按照按首字母排序           代码展示:
package com.zq.map;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;


public class Demo3 {
	public static void main(String[] args) {
		String s = "sdjsahdjshjdsdjsdiwjksjakjdsa";

		char[] arr = s.toCharArray();
		Map map = new TreeMap<>((x,y) ->y-x);
		for (char c : arr) {
			Integer value = map.get(c);
			if (value == null) {
				map.put(c, 1);
			} else {
				map.put(c, value + 1);
			}
		}
		
		//map.entrySet() 拿到映射关系
		List> aa=new ArrayList<>(map.entrySet());
		//实现接口sort
		aa.sort(new Comparator>() {
			//实现Comparator
			@Override
			public int compare(Entry o1, Entry o2) {
				return o1.getValue() - o2.getValue();
			}
		});
		
		//遍历
		for (Entry entry : aa) {
			System.out.println(entry);
		}
	}
}

        结果: 我们成功按照字母出现次数进行了升序排序!


四、泛型

 泛型:就是一种不确定的数据类型。
        比如:ArrayList E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
        泛型可以省略,如果省略,默认泛型是Object类型。
        泛型的好处:
                1. 省略了强转的代码。
                2. 可以把运行时的问题提前暴露到编译时期。

        泛型之前:不健状代码,会在运行时才会把错误暴露出来

        泛型之后:将潜在的问题暴露出来,早预防早治疗 将运行期的出现的异常转换为编译期的错误

        不加泛型:不会出现编译报错!但是运行有问题
package com.zq.map;

import java.util.HashSet;
import java.util.Set;

public class Demo4 {
	public static void main(String[] args) {
		Set set = new HashSet<>();
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);
		for (Object object : set) {
			if(Integer.valueOf(object.toString()) % 2 == 0) {
				System.out.println(object);
			}
			set.remove(object);
		}
	}
}
         加泛型后:编译直接报错,更加直观

        注意:泛型可以运用在做项目时,一些重复性的方法进行多个类的使用时,添加泛型进行编码效率的提高!
五、集合框架工具类         5.1Collection

               面试题2:分析题目,问是否出现问题?

			String[] arr={"a","b","c","d"};
			List list = Arrays.asList(arr);
//			Object[] array = list.toArray();
			list.add("e");
//			java.lang.UnsupportedOperationException
			System.out.println(list.size());
              分析:其实这里有很容易错误的题,我们一般都以为数组转成集合然后再扩大了存储空间,加了有个e,这似乎没有任何问题,但是我们要记住数组转成集合,本质上依然是一个数组,长度是不可变的

        结果为:

         ①:基本数据类型排序:

package com.zq.map;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Demo6 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("b");
		list.add("a");
		list.add("c");
		list.add("d");
		System.out.println("默认无序"+list);


		//将list集合进行排序  升序
		Collections.sort(list);
		System.out.println("升序"+list);
		
		//降序   这里的x跟y指的是集合里的元素
		Collections.sort(list, (x,y) -> y.compareTo(x));
		System.out.println("降序"+list);
	}
}

        结果为:  

         ②对象等其他数据类型排序:

package com.zq.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Demo6 {
	public static void main(String[] args) {
			List list = new ArrayList();
			list.add(new Preson("b", 12));
			list.add(new Preson("s", 14));
			list.add(new Preson("k", 19));
			list.add(new Preson("a", 18));
			System.out.println("排序前 :"+list);
			
			//实现接口的做法
			Collections.sort(list);
			System.out.println("实现接口排序后:"+list);
			
			//不实现接口的做法
			Collections.sort(list,(x,y)->x.getName().compareTo(y.getName()));
			System.out.println("不实现接口排序:"+list);
			
			Integer[] arr= {3,2,4,6,8,1};
			Arrays.sort(arr);
			System.out.println("打印地址:"+arr);
			
			
			System.out.println("默认升序: "+Arrays.toString(arr));
			
			Arrays.sort(arr,(x,y)-> y-x);
			System.out.println("降序:"+Arrays.toString(arr));
			
	}
}
	class Preson implements Comparable{
		private String name;
		private int age;
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public Preson() {
			// TODO Auto-generated constructor stub
		}
		public Preson(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
		@Override
		public String toString() {
			return "Preson [name=" + name + ", age=" + age + "]";
		}
		//实现方法
		@Override
		public int compareTo(Preson o) {
			return o.getName().compareTo(this.getName());
		}
		
	}
        结果为:  

        5.2Arrays         ①集合转换组:toArray
String[] str = {"a","b","c","d","e"};
		List list = Arrays.asList(str);
		//数组转为集合
		Object[] array = list.toArray();

        ②数组转集合:asList

String[] str = {"a","b","c","d","e"};
		List list = Arrays.asList(str);

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/962627.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号