一、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 了，放到接口后面就可以。
