一、泛型:是JDK5中引入的特性,他提供了编译是类型安全检测机制,该机制允许在编译时检测到非法的类型
他本质是参数化类型,也就是说所操作的数据类型被指定为一个参数
一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。
顾名思义,就是将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型
这种参数类型可以用在类,方法和接口中,分别被称为泛型类、泛型方法、泛型接口
1.<类型>:指定一种类型的格式。这里的类型可以看成是形参
2.<类型1,类型2,...>:指定多种类型的格式,多种类型之间用逗号隔开。这里的类型可以看成是形参
3.将具体调用时给定的类型可以看成是实参,并且实参的类型只能是引用数据类型
1.把运行时期的问题提前到了编译期间
2.避免了强制类型转换
1.格式:修饰符 class 类名<泛型>{}
此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
public class HeiMa_3{}
1.格式:修饰符<类型>返回值类型 方法名(类型 变量名){}
public void show(String s){}
1.格式:修饰符 interface 接口
{}
public interface HeiMa2_1{}
1.类型通配符:>
2.List>:表示元素类型未知的List,它是元素可以匹配任何的类型
3.这种带通配符的List仅表示它是各种泛型LIst的父类,并不能把元素添加到其中
List> l = new ArrayList
1.类型通配符上限: extends 类型>
2.List extends Number>:他表示的类型是Number或者其子类型
Number:数字
List extends Number> l4 = new ArrayList();
List extends Number> l5 = new ArrayList();
1.类型通配符的下限: super 类型>
2.List super Number>: 它表示的类型是Number或者其父类型
List super Number> l6 = new ArrayList
1.格式:修饰名 返回值类型 方法名(数据类型...变量名){}
public int sum(int... a){}
1.这里的变量其实是一个数组
2.如果一个方法有多个参数,包含可变参数,可变参数要放在最后
1、Array工具类中有一个静态方法:
public static
List :返回由指定数组支持的固定大小的列表asList 1.返回的集合不能做增删操作,可以做修改操作
List list = Arrays.asList("Hello","World","java");
list.add("javaee");
list.remove("World");
list.set(0,"javaee");
2、List接口中有一个静态方法:
public static
List :返回包含任意数量元素的不可变列表of(E...elements) 1.返回的集合不能做增删改操作
List list1 = List.of("Hello","World","java");
list1.add("javaee");
list1.remove("World");
list1.set(0,"javaee");
3、Set接口中一个静态方法:
public static
Set 返回一个包含任意数量元素的不可变集合of(E... elements): 1.在给元素的时候,不能给重复的元素
2.返回的集合不能做增删操作,没有修改的方法
Set s = Set.of("Hello","World","java");
1.Interface Map
K:键的类型;V:值的类型 2.将键映射到值的对象;不能包含重复的键;每个键可以映射到最多一个值,如果出现了重复的就代表他替换了是一个值
1.V put(K key,V value):添加元素
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
2.V remove(Object key):根据键删除键值对元素
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.remove("hm001"));
3.void clear():移除所有的键值对元素
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
m.clear();
4.boolean containsKey(Object key):判断集合是否包含指定的键
Map 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 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 m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.isEmpty());
7.int size():集合的长度,也就是集合中键对应的个数
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
m.size();
8.V get(Object key):根据键获取值
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.get("hm002"));
9.Set
KeySet() :获取所有键的集合
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.keySet());
10.Collection
values() :获取所有值的集合
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
System.out.println(m.values());
11.Set
>entrySet() :获取所以键值对对象的集合
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
Iterator> it = m.entrySet();
Map m = new HashMap<>();
m.put("hm001", "赵云");
m.put("hm002", "张良");
m.put("hm003", "曹操");
Set KeySet = m.keySet();
for(String Key : KeySet) {
System.out.println(Key);
}
1.是针对集合操作的工具类
1.public static
> void sort(List :将指定的列表按照升序排列list)
List 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 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 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
void sort(List :根据指定的比较器引起的顺序对指定的列表进行排序。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 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() {
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;
}
});