Java 之 Java 集合（泛型及集合删除方法）

泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性
泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型方法

定义泛型方法的规则：

所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔）
该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）
每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。
一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型
不能是原始类型（像int,double,char的等）。

// 创建一个集合,保存 ABCD
// <E>中 E 代表要保存的元素类型
// 新建的对象中<>和<E>中类型保存一致
// JDK 1.7出来的,菱形泛型
// 如果=前声明了泛型,那么=后面泛型可以省略不写,表示类型一致,即为<>
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
// 迭代器遍历
Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()) {
	// 添加泛型之后可以省去强转类型的麻烦
	String next = iterator.next();
	System.out.println(next);
}

泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
/*
 * 人类
 */
public class Person {
	private String name;// 姓名
	private int age;// 年龄
	// 构造
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	// get/set
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	// 重新 toString
	@Override
	public String toString() {
		return "[姓名:" + name + ", 年龄:" + age + "]";
	}
	
	
}

/*
 * 学生类
 */
public class Student extends Person{

	// 构造
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super.setName(name);
		super.setAge(age);
	}
	@Override
	public String toString() {
		return "[姓名:" + getName() + ", 年龄:" + getAge() + "]";
	}
}
/*
 * 泛型类(泛型类声明时<>中的字母自定)
 * 泛型类的类型在初始化类的对象的时候确定
 */
public class Worker<T>{
	// 利用泛型写成员变量
	private T t;
	
	// 利用泛型写 get/set 方法
	public T getT() {
		return t;
	}
	
	public void setT(T t) {
		this.t = t;
	}
	
	public void sayHi(T t) {
		System.out.println(t);
	}
	// 这里中的<T> 和上面的<T>是不一样的
	// 调用静态方法的时候,可能还没有对象,没有对象就没声明指定泛型,所有不能用
	public static<T> void fun(T t) {
		System.out.println(t);
	}
	
	// 声明不同方向得到方法,在调用泛型方法的时候,指定泛型的类型
	// <Z> 声明一个泛型,只有声明过,才能使用
	public<Z> void print(Z z) {
		System.out.println(z);
	}
	
	
	
	// 工作
	public void work() {
		System.out.println("打代码~");
	}

}
//创建集合 保存3个学生
ArrayList<Student> students = new ArrayList<>();
students.add(new Student("lbw", 21));
students.add(new Student("white", 20));
students.add(new Student("wwk", 19));
//获取迭代器
ListIterator<Student> listIterator = students.listIterator();
Student student = listIterator = student.listIterator();
Student student = listIterator.next();
System.out.println(student);

//因为Worker类和Student类没有任何关系
//所以这里会出错
//但是如果不写泛型 只有在运行期才会报错
//写上泛型 可以把运行期报错 转化到 编译器就报错
Worker worker = (Worker)listIterator.next();

? extends E(向下限定)
?是子类, E 是父类,?中只能是 E 的子类
? super   E(向上限定)
?是父类, E 是子类,?中只能是 E 的父类
/*
 * 创建一个保存人的集合
 * 创建一个保存学生的集合
 */
ArrayList<Person> personList = new ArrayList<>();
personList.add(new Person("甲", 18));
personList.add(new Person("乙", 20));

ArrayList<Student> studentlist = new ArrayList<>();
studentlist.add(new Student("丙", 22));
studentlist.add(new Student("丁", 19));

// ? extends E(只能填 E 的子类)
// studentlist extends personList
personList.addAll(studentlist);
System.out.println(personList);

int ... num 相当于传入的参数是个数组,可以接收多个参数,只能是方法参数的最后一个
JDK 1.5使用
public static void test(int ... num) {
	// 遍历
	for (int i = 0; i < num.length; i++) {
		System.out.println(num[i]);
	}
}

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

Integer[] array1 = new Integer[]{1, 2, 3, 4, 5};// 自动装箱为 Integer 类型
List<Integer> asList2 = Arrays.asList(array1);
System.out.println(asList2);
System.out.println(asList2.size());

String[] array3 = {"wanglong", "wangsong"};
List<String> asList3 = Arrays.asList(array3);
System.out.println(asList3);
System.out.println(asList3.size());
// 使用 asList 数组转集合,得到一个集合
// 注意:这个集合不予许进行添加或删除的操作
// 这样做的意义:可以调用集合的其他方法

集合中的删除方式

不使用迭代器

不使用迭代器对集合中元素进行删除
private static void test() {
	// 创建集合,保存 ABCDE
	ArrayList<String> arrayList = new ArrayList<>();
	arrayList.add("A");
	arrayList.add("B");
	arrayList.add("B");
	arrayList.add("B");
	arrayList.add("C");
	arrayList.add("B");
	arrayList.add("D");
	arrayList.add("B");
	arrayList.add("E");
	System.out.println(arrayList);
	// 不使用迭代器遍历
	// 判断集合中有无 , 有删
	for (int i = 0; i < arrayList.size(); i++) {
		if (arrayList.get(i).equals("B")) {
			// 先当参数传进去,再进行自减
			arrayList.remove(i--);
		}
	}
	System.out.println(arrayList);
}

使用迭代器

使用迭代器对集合中元素进行删除
private static void test() {
	// 创建集合,保存 ABCDE
	ArrayList<String> arrayList = new ArrayList<>();
	arrayList.add("A");
	arrayList.add("B");
	arrayList.add("B");
	arrayList.add("B");
	arrayList.add("C");
	arrayList.add("B");
	arrayList.add("D");
	arrayList.add("B");
	arrayList.add("E");
	System.out.println(arrayList);
	Iterator<String> iterator = arrayList.iterator();
	while (iterator.hasNext()) {
		String next = iterator.next();
		if (next.equals("B")) {
			// 使用迭代器删除
			iterator.remove();
		}
	}
	System.out.println(arrayList);
}

注意:不能使用 forEach即增强 for 循环
增强 for 循环遍历,底层是使用迭代器遍历的
增强 for 循环只能用来遍历,所以也叫快速遍历,不对内容进行操作

集合排序

按年龄排序
private static void test() {
	ArrayList<Student> arrayList = new ArrayList<>();
	arrayList.add(new Student("甲", 10));
	arrayList.add(new Student("乙", 19));
	arrayList.add(new Student("丙", 13));
	arrayList.add(new Student("丁", 15));
	arrayList.add(new Student("戊", 5));
	for (int i = 0; i < arrayList.size() - 1; i++) {
		for (int j = 0; j < arrayList.size() - 1 - i; j++) {
			// 获取学生
			Student s1 = arrayList.get(j);
			Student s2 = arrayList.get(j + 1);
			// 比较学生年龄
			if (s1.getAge() > s2.getAge()) {
				// 交换(修改)在集合中的位置
				// set(int index, Object obj);
				arrayList.set(j + 1, s1);
				arrayList.set(j, s2);
			}
		}
	}
	sortByName(arrayList);
	System.out.println(arrayList);
}

按姓名排序
								  // 传进来的是集合的地址
private static void sortByName(ArrayList<Student> arrayList) {
	for (int i = 0; i < arrayList.size() - 1; i++) {
		for (int j = 0; j < arrayList.size() - 1 - i; j++) {
			// 获取学生
			Student s1 = arrayList.get(j);
			Student s2 = arrayList.get(j + 1);
			// 比较姓名
			if (s1.getName().compareTo(s2.getName()) > 0) {
				// 交换位置
				Collections.swap(arrayList, j, j + 1);
			}
			
		}
	}
	System.out.println(arrayList);
}

添加学科,学科中有两个班,每个班有不同学生
public static void main(String[] args) {
	// 声明学科集合
	ArrayList<ArrayList<Student>> subject = new ArrayList<>();
	// 声明班集合
	ArrayList<Student> class01 = new ArrayList<>();
	class01.add(new Student("A", 10));
	class01.add(new Student("B", 12));
	ArrayList<Student> class02 = new ArrayList<>();
	class02.add(new Student("C", 20));
	class02.add(new Student("D", 18));
	
	// 把班添加到学科中
	subject.add(class01);
	subject.add(class02);
	
	// for 循环遍历学科中的学生
	// 通过学科找到班
	for (ArrayList<Student> classes : subject) {
		// 通过班找到学生
		for (Student student : classes) {
			// 打印学生
			System.out.println(student);
		}
	}
	// 迭代器循环遍历
	Iterator<ArrayList<Student>> iterator = subject.iterator();
	while (iterator.hasNext()) {
		ArrayList<Student> next = iterator.next();
		Iterator<Student> iterator2 = next.iterator();
		while (iterator2.hasNext()) {
			System.out.println(iterator2.next());
		}
	}
}

http://blog.csdn.net/huzongnan/article/list