Java的泛型

泛型

泛型: 标识着集合中保存的是什么类型的元素

优点:

1.操作数据更加安全(规范集合中 能保存的数据)

2.避免向下转型(强转类型) 的麻烦

3.将运行时的错误 转到编译时报错

泛型的写法一

<泛型(类型)> --- 如: ArrayList<Student>

集合的正向遍历与逆向遍历

ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");

// 正向遍历
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
	// 获取集合中的元素
	String next = listIterator.next();
	System.out.println(next);
}
// 逆向遍历
while (listIterator.hasPrevious()) {
	// 获取前一个元素
	String previous = listIterator.previous();
	System.out.println(previous);
}

泛型的作用例子:

public static void main(String[] args) {
// 不加泛型 集合中保存三个学生
ArrayList<Student> arrayList = new ArrayList<>();
arrayList.add(new Student("李乃昂", 22));
arrayList.add(new Student("李皓宁", 20));
arrayList.add(new Student("彭蕊", 18));
// 从集合中取出一个元素 打印姓名
Object object = arrayList.get(0);
Student student = (Student)arrayList.get(0);
System.out.println(student.getName());
		
// 不加泛型 打印时才报错
// 元素的类型 可以随便强转 没有约束
// 编译都会通过
// 加上泛型 在编译时就会直接提示出现错误
//Worker worker = (Worker)arrayList.get(1);
}

多参数的传参 

多参数 int ... num  可以看成一个数组 可以遍历

使用方式:

1. 直接传入一个数组

2.传入多个数 用逗号分开

注意: 多个参数时 把多参数放在最后

public static void fun4(int a, int ... num) {
for (int i = 0; i < num.length; i++) {
	System.out.println(num[i]);
}
System.out.println(a);
}

// 调用一下多参数
// 方式一
int[] array = {11,20,3,24,35};
fun4(1,array);
// 方式二
fun4(10,30,20,40,26);

数组转集合

使用asList方法 将数组转化成集合

注意: 不能对集合的长度发生改变(不能增删)

转化成集合后 可以调用集合中的其他方法

// 数组转集合
int[] array = {1,2,3,4,5};
// 根据泛型 这个集合中 每一个元素 都是一个数组
List<int[]> list = Arrays.asList(array);
System.out.println(list);
// 直接传入int数组 系统不会帮你进行自动装箱---将基本数据类型的数组 当成了一个元素
Integer[] newArray = {1,2,3,4,5};
// 直接把数组中的元素 放入了集合中
List<Integer> asList = Arrays.asList(newArray);
System.out.println(asList);

泛型的写法二

? extends E   问号是子类 E是父类

只能使用 父类的子类 或 本类

也叫 向下限定

addAll(Collection<? extends E> c) 

// 创建一个Person集合 保存两个person
ArrayList<Peraon> list1 = new ArrayList<>();
list1.add(new Peraon("wang1",11));
list1.add(new Peraon("wang2",11));
// 创建一个student集合 保存两个
ArrayList<Student> list2 = new ArrayList<>();
list2.add(new Student("peng1",11));
list2.add(new Student("peng2",11));
// addAll(Collection<Student extends Person> c)
list1.addAll(list2);
//list2.addAll(list1);
System.out.println(list1);

例: 创建一个集合 保存a b c d

    如果有b 就把b删掉

循环删除

ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("b");
list.add("b");
for (int i = 0; i < list.size(); i++) {
	if (list.get(i).equals("b")) {
		list.remove(i);
		// 删除后 要退回角标 list.remove(i--);
		i--;
	}
}
System.out.println(list);

迭代器删除

ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("b");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
	String next = listIterator.next();
	if (next.equals("b")) {	
	    listIterator.remove();
	}
}
System.out.println(list);

注意:

迭代器中需要使用

迭代器类中的删除方法

避免出现并发修改异常

Collections的swap交换方法

//  创建一个集合 保存三个学生 
//  按年龄排序
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("li1", 18));
list.add(new Student("li2", 14));
list.add(new Student("li3", 16));
// 冒泡
for (int i = 0; i < list.size() - 1; i++) {
	for (int j = 0; j < list.size() - 1 - i; j++) {
		// 找出j 和 j+1的两个学生
		Student s1 = list.get(j);
		Student s2 = list.get(j+1);
		if (s1.getAge() > s2.getAge()) {
			Collections.swap(list,j,j+1);
		}
	}
}
System.out.println(list);

明天会更好!