集合架构-Map集合及工具类

最新推荐文章于 2024-08-02 18:42:00 发布

云小君

最新推荐文章于 2024-08-02 18:42:00 发布

阅读量636

点赞数

文章标签： java 开发语言前端 eclipse

本文链接：https://blog.csdn.net/SAME_LOVE/article/details/131252543

版权

一、Map集合介绍

简介:

1.Map集合是我们常使用的集合，了解和使用map集合是必要的。

2.Map不能直接创建对象，可以通过多态的形式创建对象。

3.Map是一个双列集合，一个元素包含两个值（一个key，一个value）,key表示键，value表示值。

4.Map集合中的元素，key和value的数据类型可以相同，也可以不同，并且key和value是一一对应的。

5.Map中不能包含重复的键，若是有重复的键添加，则会以最后一次的键为准，而本次添加的键会被覆盖，value(值)为将被修改。

6.Map集合有子类:一是HashMap，另一个是TreeMap。

常用方法

map.put(K key, V value);	将键（key）/值（value）映射存放到Map集合中
map.get(Object key);	返回指定键所映射的值，没有该key对应的值则返回 null
map.size();	返回Map集合中数据数量
map.clear();	清空Map集合
map.isEmpty ();	判断Map集合中是为空，空则返回true，否则返回false
map. containsKey(key);	判断集合中是否包含指定的键
map.containsValue(value);	判断集合中是否包含指定的值
map.remove(Object key);	根据键删除键和对应的值

二、Map的增删改查

实例化:

Map m = new HashMap();

1.增

//增加元素
m.put("a", 1);
m.put("b", 2);
m.put("c", 3);
m.put("d", 4);

2.改

//根据键(key)修改，第二参数是改后的值(value)
m.put("b", 7);
//根据键(key)修改，第二参数是旧值，第三参数是新值
m.replace("c", 3, 9);

3.删

//根据键(key)删除
m.remove("a");

4.查

//根据键查看，可打印返回值查看
m.get("c");

三、Map的遍历方法

1.EntrySet

//实例化Map集合
Map m = new HashMap();
//增加元素
m.put("a", 1);
m.put("b", 2);
m.put("c", 3);
m.put("d", 4);
//遍历方式entrySet
Set set = m.entrySet();
for (Object o : set) {
	Map.Entry entry = (Map.Entry) o;
	System.out.println("key键为:"+entry.getKey()+"--value值为:"+entry.getValue());
}

输出结果:

2.KeySet

//实例化Map集合
Map m = new HashMap();
//增加元素
m.put("a", 1);
m.put("b", 2);
m.put("c", 3);
m.put("d", 4);
//遍历方式keySet
Set set2 = m.keySet();
for (Object obj : set2) {
System.out.println("键为:"+obj+"--value值为:"+m.get(obj));
 }

输出结果:

四、Map集合的泛型

概括:

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

1.使用泛型

package com.SAME_LOVE.Map;

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

/**
 * @author SAME_LOVE
 * @com.SAME_LOVE.Map
 * @Demo03(说明):Map集合的泛型（概述及使用.泛型类.泛型方法）
 * 概述: 将运行时的异常转换为编译时的错误 并且可以高代码的健壮行
 */
public class Demo03 {

	public static void main(String[] args) {

		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);
		map.put("e", 5);
		for (Map.Entry<String, Integer> m : map.entrySet()) {
			// 求出map集合中所有奇数值
			if (m.getValue() % 2 == 1) {
				System.out.println(m.getValue() + "为奇数");
			} else {
				// 求出map集合中所有偶数值
				System.out.println(m.getValue() + "为偶数");
			}
		}
	}
}

输出结果为:

2.泛型类

代码内有注解及说明

package com.SAME_LOVE.Map;

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

/**
 * @author SAME_LOVE
 * @com.SAME_LOVE.Map
 * @Demo03(说明):Map集合的泛型（概述及使用.泛型类.泛型方法） 概述: 将运行时的异常转换为编译时的错误 并且可以高代码的健壮行
 */
public class Demo03 {
	
}

// 学生类
class Student {

}
// 书类
class Book {

}
/**
 * @author SAME_LOVE
 * @com.SAME_LOVE.Map
 * @BaseDao(说明):该类封装所以方法
 */
class BaseDao<T> {
	/**
	 * T 是泛型类
	 * @param t
	 * 方法参数是可以同名的，只是不同参数
	 * 在此只需该变泛型类(T)就可以拥有该类(BaseDao)的方法
	 */
	// 有增加的方法
	public int Add(T t) {
		return 0;
	}
	// 有修改的方法
	public int Edit(T t) {
		return 0;
	}
	// 有删除的方法
	public int Del(T t) {
		return 0;
	}
}
/**
 * @author SAME_LOVE
 * @com.SAME_LOVE.Map
 * @StudentDao(说明):比如这是学生类的数据访问层
 * 继承BaseDao类后尖括号里的泛型类是Student类，那BaseDao类的泛型类就是Student类
 * 在此继承后,StudentDao类里面就相当于有了BaseDao的增删改的方法
 */
class StudentDao extends BaseDao<Student>{
	public static void main(String[] args) {
		new StudentDao().Add(new Student());//学生类的增加
		new StudentDao().Edit(new Student());//学生类的修改
		new StudentDao().Del(new Student());//学生类的删除
	}
}/**
 * @author SAME_LOVE
 * @com.SAME_LOVE.Map
 * @StudentDao(说明):比如这是书类的数据访问层
 * 继承BaseDao类后尖括号里的泛型类是Book类，那BaseDao类的泛型类就是Book类
 * 在此继承后,BookDao类里面就相当于有了BaseDao的增删改的方法
 */
class BookDao extends BaseDao<Book>{
	public static void main(String[] args) {
		new BookDao().Add(new Book());//书类的增加
		new BookDao().Edit(new Book());//书类的修改
		new BookDao().Del(new Book());//书类的删除
	}
}

3.泛型方法

public <T> Map data(String key,T value){
        System.out.println("泛型方法");
        return null;
    }

五、集合框架工具类

1.Collections

进行排序(代码演示):

public static void main(String[] args) {
	 List<String> list = new ArrayList<String>();
	 //增加元素对象
	 list.add("c");
	 list.add("b");
	 list.add("d");
	 list.add("a");
	 System.out.println("排序前"+list);
	 //框架工具类方调用(排序)
	 Collections.sort(list);
	 System.out.println("排序后"+list);
	 //调用工具类(Collections)sort方法降序
	 Collections.sort(list,new Comparator<String>() {
	 @Override
	 public int compare(String o1, String o2) {
	 //想要升序参数o1与o2调换即可
	 return o2.compareTo(o1);
	 }
	 });
	 System.out.println("排序后"+list);
	 }

输出结果为:

对对象进行排序（代码演示）:

public static void main(String[] args) {
	 //对于引用对象
	 List<Per> list = new ArrayList<Per>();
	 list.add(new Per(2, "小黑子"));
	 list.add(new Per(1, "ikun"));
	 list.add(new Per(4, "花姑凉"));
	 list.add(new Per(3, "密西西"));
	 System.out.println("没排序前");
	 for (Per per : list) {
	 System.out.println(per);
	 }
	 System.out.println("已排序后");
	 Collections.sort(list);
	 for (Per per : list) {
	 System.out.println(per);
	 }
	 }
	 }
	 class Per implements Comparable<Per>{
	 private int id;
	 private String name;
	 public int getId() {
	 return id;
	 }
	 public void setId(int id) {
	 this.id = id;
	 }
	 public String getName() {
	 return name;
	 }
	 public void setName(String name) {
	 this.name = name;
	 }
	 @Override
	 public String toString() {
	 return "Per [id=" + id + ", name=" + name + "]";
	 }
	 public Per(int id, String name) {
	 super();
	 this.id = id;
	 this.name = name;
	 }
	 @Override
	 public int compareTo(Per o) {
	 //根据元素对象编号升序
	 return this.id - o.id;
	 }

输出结果为:

Collections 是一个操作Set、List和Map等集合的工具类，提供了一系列静态方法对集合元素进行排序、查询和修改等操作。

还可以进行数字进行排序(升序，降序)，操作也是以上一样的进行，只需将元素该为数字。

2.Arrays

进行排序(代码演示):

public static void main(String[] args) {
		// 定义数组
		String[] arr = new String[] { "c", "d", "a", "b" };
		// 将数组转换会集合
		List<String> list = Arrays.asList(arr);
		System.out.println("没有排序前:"+list);
		// 调用集合工具类Arrays的方法进行降序
		Arrays.sort(arr, new Comparator<String>() {
			// 重写方法
			@Override
			public int compare(String o1, String o2) {
				return o2.compareTo(o1);
			}
		});
		System.out.println("Arrays的方法进行降序"+list);
		// 调用集合工具类Arrays的方法进行升序
		Arrays.sort(arr, new Comparator<String>() {
			//重写方法
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		System.out.println("Arrays的方法进行升序"+list);
	}

最后输出结果为:

实现Comparator接口的方法实在太繁琐，你还要为此创建一个类来重写conpare方法，于是，匿名内部类的优点就体现出来了。

new Comparator<String>()后面的大括号的内容相当于一个没有名字的类，它实现了不用起名字，也不用implements Comparator 了，放到接口后面就可以。

云小君

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
集合架构-Map集合及工具类

1.Map集合是我们常使用的集合，了解和使用map集合是必要的。2.Map不能直接创建对象，可以通过多态的形式创建对象。3.Map是一个双列集合，一个元素包含两个值（一个key，一个value）,key表示键，value表示值。4.Map集合中的元素，key和value的数据类型可以相同，也可以不同，并且key和value是一一对应的。5.Map中不能包含重复的键，若是有重复的键添加，则会以最后一次的键为准，而本次添加的键会被覆盖，value(值)为将被修改。
复制链接

扫一扫