java ——泛型

泛型：标识着集合中保存的元素

 <泛型（类型）>

泛型的好处：

1.操作数据更加安全,规范集合中，能保存的数据(增加了代码的安全性)

2.避免向下转型的麻烦(省去了强制转换的麻烦)

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

泛型类:增加了代码的可扩展性 （可以在类中 使用泛型）

public static void main(String[] args) {
		// fun1();
		// fun2();
		// fun3();
		// fun5();
		// fun6();
		
		String[] strings = {"liubei","caocao","sunquan"};
		// 数组转集合
		List<String> list = Arrays.asList(strings);
		// 添加一个元素
		//
		// 不支持的操作异常
		// 使用asList方法 将数组转化成集合
		// 注意：不能对集合的长度发生改变（不能增删）
		// 转化成集合 可以调用集合中其他方法
		// list.add("erlangshen");
		boolean b= list.contains("liubei");
		System.out.println(b);
	}
	private static void fun6() {
		// 数组转集合
		int[] array = {1,2,3,4,5};
		// 根据泛型 这个集合中 每一个元素都是一个数组
		Arrays.asList(array);
		List<int[]> list = Arrays.asList(array);
		System.out.println(list);
		// 直接传入 int[] 系统不会帮你进行自动装箱，，，，
		
		Integer[] newArray = {1,2,3,4,5};
		// 直接把数组中的元素放入集合中
		List<Integer> newList = Arrays.asList(newArray);
		System.out.println(newList);
	}
	private static void fun5() {
		// 调用一下多参数方法
		int[] array = {1,2,3,4,5};
//		fun4(array);
		// 方式二
		fun4(10,20,30,40,50,60);
	}
	// 多参数的参数
	// 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]);
		}
	}

	private static void fun3() {
		Worker<String> worker = new Worker<>();
		worker.setE("工人阶级力量大！");
		System.out.println(worker.getE());
		worker.fun("嘿嘿");
		worker.worker();
	}

	private static void fun2() {
		ArrayList list = new ArrayList();
		list.add(new Student("小明", 11));
		list.add(new Student("小宇", 11));
		list.add(new Student("小天", 11));
		Object object = list.get(0);
		Student student = (Student) object;
		System.out.println(student.getName());
		// 从集合中取出一个元素 强转成工人类型
		// 调用工人的工作方法
		// 不加泛型 获取到的集合中的元素
		// 元素的类型你可以 随便强转 没有约束
	}

	private static void fun1() {
		// 泛型 前后要一致
		// jdk1.7 菱形泛型
		// 后面的类型可以省略
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		// 遍历集合
		ListIterator<String> iterator = list.listIterator();
		// while (iterator.hasNext()) {
		// // 获取集合中的元素
		// String string = iterator.next();
		// System.out.println(string);
		// }
		// 逆向遍历
		// 判断前一个是否有元素
		while (iterator.hasPrevious()) {
			// 取出前一个元素
			String previous = iterator.previous();
			System.out.println(previous);
		}
	}

泛型接口

interface InterA<M> {
	public abstract void fun(M m);
}

泛型实现类

lass InterAImpl implements InterA<String> {

	@Override
	public void fun(String m) {
		// TODO Auto-generated method stub

	}

}

 泛型通配符

? extends E  //其中 ?是子类,E是父类,向下限定只允许子类或者孙子类等,向下限定
 collection<? extends E> 表示的是collection类型要是E的子类或者向下的类型

? super E 向上限定 只允许父类

public static void main(String[] args) {
		// 测试拼音类
		String firstLetter = Pinyin4jUtil.getFirstLetter("筱雨");
		System.out.println(firstLetter);
		// fun1();
		// fun2();
		// fun3();
		// 创建一个集合 保存三个学生
		// 按年龄排序
		  ArrayList<Student> arrayList = new ArrayList<>();
		  arrayList.add(new Student("王老头", 78));
		  arrayList.add(new Student("李老头", 81));
		  arrayList.add(new Student("老赵头", 80));
		  for (int i = 0; i < arrayList.size(); i++) {
			for (int j = 0; j < arrayList.size() - 1 - i; j++) {
				// 找出j 与j+1 的学生
				Student s1 = arrayList.get(j);
				Student s2 = arrayList.get(j + 1);
				// 按年龄排序 
				if (s1.getAge() > s2.getAge()) {
					// 交换学生 s1和s2
//					Student temp = s1;
//					arrayList.set(j, s2);
//					arrayList.set(j + 1, temp);
					// 使用工具类方法
					Collections.swap(arrayList, j, j + 1);
				}
			}
		}
		  System.out.println(arrayList);
	}

	private static void fun3() {
		// 迭代器删除
		// 如果有b 就把b删除（使用循环）
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("s");
		list.add("b");
		ListIterator<String> iterator = list.listIterator();
		while (iterator.hasNext()) {
			String string = iterator.next();
			if (string == "b") {
				// 迭代器中 需要使用
				// 迭代器类中的删除方法
				// 避免出现并发修改异常
				// 从列表中移除由 next或 previous返回的最后一个元素（可选操作）
				// 如果添加元素要使用list中特有的迭代器,
				// 如果要删除,collection和list的迭代器都是可以删除的
				iterator.remove();
			}
		}
		System.out.println(list);
	}

	private static void fun2() {
		// 循环删除
		// 创建一个集合保存a,b,c,d
		// 如果有b 就把b删除（使用循环）
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("s");
		list.add("b");
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i) == "b") {
				list.remove(i);
				// 表示每次删除后都把角标回调一次,
				// 为了保证删除后也能遍历到数组每一个元素
				i--;
			}
		}
		System.out.println(list);
	}

	private static void fun1() {
		// addAll(collection<? extends E> C)
		// 创建一个person集合 保存2个person
		ArrayList<Person> list1 = new ArrayList<>();
		list1.add(new Person("xuan1", 12));
		list1.add(new Person("xuan2", 13));
		// 创建一个student集合 保存2个student
		ArrayList<Person> list2 = new ArrayList<>();
		list1.add(new Person("yuan1", 12));
		list1.add(new Person("yuan2", 13));
		// addAll(collection<? extends E> C)
		list1.addAll(list2);
		// list2.addAI(list1);
		System.out.println(list1);
	}

泛型类

可以在类的声明上 添加一个泛型

使用的字母(Aa-Zz)

这个泛型可以在类中使用

类上声明的泛型

会在创建对象的时候 被赋值真正的类型

public class Worker<E> {
	// 成员变量
	private E e;
	// 成员方法set/get
	public void setE(E e) {
		this.e = e;
	}
	public E getE() {
		return e;
	}
	// 一个类中 可以存在几个泛型
	// 如果你在方法中声明新的泛型
	// 该泛型会在方法被调用的时候 赋值泛型
	// 需要在方法中 声明出来 泛型
	public<W> void fun(W w) {
		System.out.println(w);
	}
	// 静态方法不能使用 泛型E
	// 不能使用 类声明上的泛型
	// 直接使用类型调用静态方法的时候
	// 有对象的处境 E泛型还没有被赋值
	// 使用泛型可以 单独声明一下（static后面）
	public static<Q> void sayHi(Q q) {
		
	}
	
	public void worker() {
		System.out.println("我在工作");
	}
}