Java 集合之泛型详解

泛型

/*
* 保存字符串
* ArrayList<E> E就代表 要保存的元素类型
* 后面的尖括号 要跟前面填的泛型保持一致
* 如果前面声明了泛型 后面泛型可以省略不写 省略不写 表示类型一致
* jdk1.7 菱形泛型
*/
public static void fun1() {
// 创建一个集合 保存a b c d
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// 遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
// 添加泛型之后 可以省去强转类型的麻烦
String next = iterator.next();
System.out.println(next);
}
}

/*
* 写泛型编译期就会报错
*/
public static void fun2() {
// 创建集合 保存3学生
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("aaa", 12));
list.add(new Student("bbb", 15));
list.add(new Student("ccc", 18));
// 获取迭代器
Iterator<Student> iterator = list.iterator();
Student next = iterator.next();
System.out.println(next);

// 设置泛型 可以把运行期报错 转化到编译期就报错
// Worker worker = (Worker)iterator.next();
}

泛型类

泛型类(泛型类声明时  尖括号中的字母 可以随便定义)
泛型类的类型在初始化这个类的对象的时候确定

代码示例:
public class Worker<T> {
// 利用泛型写成员变量
private T t;
// 利用泛型写 set/get 方法
public T getT() {
return t;
}

public void setT(T t) {
this.t = t;
}
// 普通成员方法
public void sayHi(T t) {
System.out.println(t);
}
// 声明不同泛型的方法 在调用泛型方法的时候 指定泛型的类型
// <Z> 声明一个泛型 只有声明过 才能使用
public<Z> void print(Z z) {
System.out.println(z);
}
// 静态方法不能直接使用T,当你调用静态方法的时候可能还没有对象,没有对象就没有指定泛型所以不能用
public static<R> void fun(R r) {
System.out.println(r);
}
// 工作方法
public void work() {
System.out.println("搬砖");
}
}

public static void fun3() {
// 创建泛型类
Worker<String> worker = new Worker<>();
// 给属性赋值
worker.setT("hhh");
System.out.println(worker.getT());
// 调用成员方法
worker.sayHi("...");
// 调用 方法 给定类型
worker.print("---");
Worker.fun("***");
worker.work();
}

泛型接口

// 泛型接口
interface InterA<W>{
public abstract void fun(W w);
}

// 实现类
class InterAImpl implements InterA<String>{
@Override
public void fun(String w) {
System.out.println(w);
}
}

public static void main(String[] args) {
// 创建实现类
InterAImpl impl = new InterAImpl();
impl.fun("```");
}

向下限定/向上限定

? extends E (向下限定)
?是子类 继承 E是父类  ?只能是 E类 的子类

? super   E(向上限定)
?是父类    E是子类   ?只能是E类的 父类

? extends E (向下限定) 代码:
/*
* 需求:
* 创建一个保存人的集合  存2人
* 创建一个保存学生的集合 存2人
*/
ArrayList<Person> persons = new ArrayList<>();
persons.add(new Person("qwe", 11));
persons.add(new Person("asd", 15));

ArrayList<Student> students = new ArrayList<>();
students.add(new Student("zxc", 20));
students.add(new Student("rty", 21));
//  学生的集合 全部添加到 人的集合中
// ? extends Person 只能填Person的子类
// students.addAll(persons);
persons.addAll(students);
System.out.println(persons);

int … num

int ... num 相当于传入的参数是个数组,可以接受多个参数 但是只能是方法参数的最后一个

代码:
public static void fun2(int ... num) {
// 遍历
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}
}
// 调用方式一 直接传入数组
int[] array = {1, 3, 5, 7, 9};
fun2(array);
// 调用方式二 传入多个数
fun2(1, 2, 3, 4, 5, 6, 7, 8, 9);

数组转集合

使用Arrays类方法把数组转换为集合:

int[] array = {1, 3, 5, 7, 9};// 没有进行自动装箱
// 把数组当做集合中的一个元素转为了集合
List<int[]> asList = Arrays.asList(array);
System.out.println(asList);

Integer[] array2 = {1, 3, 5, 7, 9};
List<Integer> asList2 = Arrays.asList(array2);
System.out.println(asList2);

String[] array3 = {"wanglong","wangwu"};
// 使用asList数组转集合 得到一个集合
List<String> asList3 = Arrays.asList(array3);
boolean contains = asList3.contains("wanglong");
System.out.println(asList3);
System.out.println(contains);

注意:这个集合不允许进行添加或删除的操作,可以调用集合的其他方法

集合中的删除方法

1.不使用迭代器
// 创建一个集合
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
// 不使用迭代器 遍历
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals("b")) {
// 先当参数传进去  在进行自减
list.remove(i--);
}
}
System.out.println(list);

2.使用迭代器
// 创建一个集合
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("b");
list.add("d");
list.add("e");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
if (iterator.next().equals("b")) {
iterator.remove();
}
}
System.out.println(list);