Java基础篇--泛型和Map集合

泛型

---

一、泛型概述：

一、泛型：是JDK5中引入的特性，他提供了编译是类型安全检测机制，该机制允许在编译时检测到非法的类型

他本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类，方法和接口中，分别被称为泛型类、泛型方法、泛型接口

二、泛型定义的格式：

1.<类型>：指定一种类型的格式。这里的类型可以看成是形参

2.<类型1，类型2，...>:指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参

3.将具体调用时给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

三、泛型的好处：

1.把运行时期的问题提前到了编译期间

2.避免了强制类型转换

四、泛型类的定义式：

1.格式：修饰符 class 类名<泛型>{}

此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

public class HeiMa_3<T>{}

五、泛型的方法：

1.格式：修饰符<类型>返回值类型 方法名(类型 变量名){}

public <String> void show(String s){}

 六、泛型接口：

1.格式：修饰符 interface 接口<T>{}

public interface HeiMa2_1<String>{}

 类型通配符

---

一、为了表示各种泛型List的父类，可以使用类型通配符

1.类型通配符：<?>

2.List<?>:表示元素类型未知的List，它是元素可以匹配任何的类型

3.这种带通配符的List仅表示它是各种泛型LIst的父类，并不能把元素添加到其中

List<?> l = new ArrayList<Object>();

二、如果说我们不希望List<?>是任何类型的父类，只希望它代表某一类泛型LIst的父类，可以使用类型通配符的上限

1.类型通配符上限：<? extends 类型>

2.List<? extends Number>:他表示的类型是Number或者其子类型

Number:数字 

List<? extends Number> l4 = new ArrayList<Number>();
List<? extends Number> l5 = new ArrayList<Integer>();

 三、除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

1.类型通配符的下限：<? super 类型>

2.List<? super Number>: 它表示的类型是Number或者其父类型

List<? super Number> l6 = new ArrayList<Object>();
List<? super Number> l7 = new ArrayList<Number>();

 可变参数

---

一、可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

1.格式：修饰名 返回值类型 方法名(数据类型...变量名){}

public int sum(int... a){}

 二、可变参数的注意事项

1.这里的变量其实是一个数组

2.如果一个方法有多个参数，包含可变参数，可变参数要放在最后

三、可变参数的使用 

1、Array工具类中有一个静态方法：

        public static<T>List<T>asList<T...a>:返回由指定数组支持的固定大小的列表

1.返回的集合不能做增删操作，可以做修改操作

List<String> list = Arrays.asList("Hello","World","java");
list.add("javaee");
list.remove("World");
list.set(0,"javaee");

 2、List接口中有一个静态方法：

        public static <E> List<E> of(E...elements):返回包含任意数量元素的不可变列表

1.返回的集合不能做增删改操作

List<String> list1 = List.of("Hello","World","java");
list1.add("javaee");
list1.remove("World");
list1.set(0,"javaee");

 3、Set接口中一个静态方法：

        public static <E> Set<E> of(E... elements):返回一个包含任意数量元素的不可变集合

1.在给元素的时候，不能给重复的元素

2.返回的集合不能做增删操作，没有修改的方法

Set<String> s = Set.of("Hello","World","java");

 Map集合

---

一、Map集合概述:

1.Interface Map<K,V>        K:键的类型；V：值的类型

2.将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值，如果出现了重复的就代表他替换了是一个值

二、Map集合的基本功能: 

1.V put(K key,V value):添加元素

Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");

2.V remove(Object key):根据键删除键值对元素

Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.remove("hm001"));

3.void clear():移除所有的键值对元素

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
m.clear();

4.boolean containsKey(Object key):判断集合是否包含指定的键

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.containsKey("hm002"));
System.out.println(m.containsKey("02"));

5.boolean containsValue(Object Value):判断集合是否包含指定的值

Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.containsValue("hm002"));
System.out.println(m.containsValue("赵云"));

6.boolean isEmpty():判断集合是否为空

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.isEmpty());

7.int size():集合的长度，也就是集合中键对应的个数

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
m.size();

8.V get(Object key):根据键获取值

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.get("hm002"));

9.Set<K>KeySet():获取所有键的集合

​​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.keySet());

10.Collection<V>values():获取所有值的集合

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.values());

11.Set<Map.Entry<K,V>>entrySet():获取所以键值对对象的集合

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
Iterator<Map.Entry<Integer,Integer>> it = m.entrySet();

三、遍历Map集合:

​Map<String,String> m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
Set<String> KeySet = m.keySet();
for(String Key : KeySet) {
    System.out.println(Key);
}

Collections

---

一、Collections类的概述:

1.是针对集合操作的工具类

二、Collections类的常用方法: 

1.public static<T extends Comparable<? super T>> void sort(List<T> list):将指定的列表按照升序排列

List<Integer> l = new ArrayList<>();
l.add(10);
l.add(30);
l.add(56);
l.add(61);
l.add(85);
l.add(22);
l.add(22);
Collections.sort(l);

2. public static void reverse(List<?> list):反转指定列表中元素的顺序

List<Integer> l = new ArrayList<>();
l.add(10);
l.add(30);
l.add(56);
l.add(61);
l.add(85);
l.add(22);
l.add(22);
Collections.reverse(l);

3.public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表

List<Integer> l = new ArrayList<>();
l.add(10);
l.add(30);
l.add(56);
l.add(61);
l.add(85);
l.add(22);
l.add(22);
Collections.shuffle(l);

4.public static<T> void sort(List<T> list,Comparator<? super T> c):根据指定的比较器引起的顺序对指定的列表进行排序。

public class sum {
	private String name;
	private int age;
	public HeiMa14_1() {}
	public HeiMa14_1(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
}

List<HeiMa14_1> l = new ArrayList<>();
sum s1 = new sum("张无忌",53);
sum s2 = new sum("张三丰",42);
sum s3 = new sum("张无极",33);
sum s4 = new sum("张无慌",23);
l.add(s4);
l.add(s3);
l.add(s2);
l.add(s1);
Collections.sort(l,new Comparator<HeiMa14_1>() {
public int compare(HeiMa14_1 hm5,HeiMa14_1 hm6) {
	int num1 = hm5.getAge() - hm6.getAge();
	int num2 = num1 == 0?hm5.getName().compareTo(hm6.getName()) : num1;
	return num2;
	}
});