Java进阶之路~泛型

一 泛型

标识着集合中保存的元素

<泛型(类型)> eg: ArrayList<String>

好处:

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

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

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

二 正向遍历与逆向遍历

public static void main(String[] args){
   ArrayList<String> list = new ArrayList<>();
   list.add("a");
   list.add("b");
   list.add("c");
   list.add("d");
   ListIterator<String> lisIterator = list.listIterator();
   while(lisIterator.hasNext()){
      String string = lisIterator.next();
      System.out.println(string);
   }
}

public static void main(String[] args){
   ArrayList<String> list = new ArrayList<>();
   list.add("a");
   list.add("b");
   list.add("c");
   list.add("d");
   ListIterator<String> lisIterator = list.listIterator();
   while(lisIterator.hasNext()){
      String string = lisIterator.next();
      System.out.println(string);
   }
   while (listIterator.hasPrevious()) {
      //获取前一个元素
      string previous = listIterator.previous();
      System.out.println(previous);
   }
}

需要注意的是:在使用迭代器遍历时,其内部的指针在第一个元素的上面,所以正向遍历时,判断指针下一个位置有元素执行遍历.

执行完毕后,内部指针在最后一个元素位置上,此时逆向遍历,判断指针上一个位置有元素执行遍历.因此,如若未执行正向遍历而直接进行逆向遍历,是无法执行的.

三 强转型时泛型的编译报错

public static void fun2() {
	//不加泛型 集合中保存三个学生
	ArrayList list = new ArrayList();
	list.add(new Student("恐龙",18));
	list.add(new Student("大海",18));
	list.add(new Student("地狱",18));
	//从集合中取出一个元素
	Object object = list.get(0);
	Student student = (Student)object;
	System.out.println(student.getName());
	//从集合中取出一个元素 强转型工人类型
	//调用工人的工作方法
	//不加泛型 获取到集合中的元素
	//元素的类型你可以随便强转,编译不报错
	Object object2 = list.get(1);
	Worker worker = (Worker)object2;
	worker.work();
	//加上泛型 可以在编译时 有错误提示
	//让集合中保存的元素 更加安全
//	Worker worker2 = (Worker)list.get(0);
}

四 基本数据类型数组转集合时

public static void fun6() {
	//数组转集合
	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);
}

五 数组转集合 需注意的地方

使用aslist方法,将数组转化成集合,其长度不能发生改变

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

public static void main(String[] args) {
	String[] strings = {"wanglong","pengqian","xiaofeng"};
	//数组转集合
	List<String> list = Arrays.asList(strings);
	//添加一个元素
	//UnsupportedOperationException
	//不支持的操作异常
//	list.add("kuner");
//	System.out.println(list);
	boolean b = list.contains("wanglong");
	System.out.println(b);
}

六 ? extends E

? 子类   ,    E 父类

public static void fun1() {
	//addAll(Collection<? extends E> c)
	//创建一个person集合 保存两个person
	ArrayList<Person> list1 = new ArrayList<>();
	list1.add(new Person("wang1",11));
	list1.add(new Person("wang2",11));
	//创建一个student集合 保存两个person
	ArrayList<Student> list2 = new ArrayList<>();
	list2.add(new Student("peng1",11));
	list2.add(new Student("peng2",11));
	//addAll(Collection<? extends Person> c)
	list1.addAll(list2);
	System.out.println(list1);
//	list2.addAll(list1); //报错
}

七 删除元素需注意的

public static void fun2() {
	//循环删除
	//创建一个集合保存 abcd
	//如果有b 就把b删了(使用循环)
	ArrayList<String> list = new ArrayList<>();
	list.add("a");
	list.add("b");
	list.add("b");
	list.add("c");
	list.add("d");
	for (int i =    0; i < list.size(); i++) {
		if (list.get(i).equals("b")) {				
		//删除之后,要退回角标,因为删除之后,数组中的元素会向前移动一位
		list.remove(i);
		}
	}
	System.out.println(list);
}

在其删除元素后,数组中后面的元素会向前移动一位,所以会出现上述情况

可在删除的同时,将i减一即可

或者用迭代器删除

public static void fun3() {
	//迭代器删除
	ArrayList<String> list = new ArrayList<>();
	list.add("a");
	list.add("b");
	list.add("b");
	list.add("c");
	list.add("d");
	Iterator iterator = list.iterator();
	while (iterator.hasNext()) {
		String next = (String)iterator.next(); 
		if (next.equals("b")) {
			iterator.remove();
		}
	}
	System.out.println(list);
}