Java--集合(LinkedList，泛型)

LinkedList

一、LinkedList类

[1]public void addFirst(E e)及addLast(E e)

[2]public E getFirst()及getLast()

[3]public E removeFirst()及public E removeLast()

[4]public E get(int index);

栈：先进后出，底端闭口

队列：先进先出，两端开口

import java.util.ArrayList;
import java.util.LinkedList;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class LinkedListMethod {
	public static void main(String[] args) {
		/*
		 * 一、LinkedList类
				[1]public void addFirst(E e)及addLast(E e)
				[2]public E getFirst()及getLast()
				[3]public E removeFirst()及public E removeLast()
				[4]public E get(int index);
		 * */
		initLinkedList();
		simulateSatck();//使用LinkedList模拟栈操作
		simulateQueue();//使用LinkedList模拟栈操作
	}

	//使用LinkedList模拟栈操作(先进后出)
	private static void simulateSatck() {
		System.out.println("===========模拟栈、队列============");
		Stack s = new Stack();
		s.in("a");
		s.in("b");
		s.in("c");
		s.in("d");
		s.forAll();
		System.out.println();
		while(!s.isEmpty()){
			System.out.print(s.outStack() + " ");
		}
		System.out.println();
	}
	
	//使用LinkedList模拟栈操作(先进后出)
	private static void simulateQueue() {
		System.out.println("===========模拟队列============");
		Stack s = new Stack();
		s.in("a");
		s.in("b");
		s.in("c");
		s.in("d");
		s.forAll();
		System.out.println();
		while(!s.isEmpty()){
			System.out.print(s.outQueue() + " ");
		}
		System.out.println();
	}

	private static void initLinkedList() {
		LinkedList li = new LinkedList();
		li.addFirst("a");
		li.addFirst("b");
		li.addFirst("c");
		li.addLast("e");
		System.out.println(li);
		li.removeFirst();
		li.removeLast();
		System.out.println(li);
		System.out.println(li.get(1));
	}
}

LinkedList模拟栈和队列操作

import java.util.LinkedList;

public class Stack {
	@SuppressWarnings("rawtypes")
	private LinkedList list = new LinkedList();
	
	@SuppressWarnings("unchecked")
	public void in(Object obj){
		list.add(obj);
	}
	
	//栈----先进后出
	public Object outStack(){
		return list.removeLast();
	}
	
	//队列----先进先出
	public Object outQueue(){
		return list.removeFirst();
	}
	
	public boolean isEmpty(){
		return list.isEmpty();
	}
	
	public void forAll(){
		for(int i = 0;i < list.size();i++){
			System.out.print(list.get(i) + " ");
		}
	}
}

泛型

一、泛型概述和基本使用

1、泛型的由来:通过Object转型问题引入

 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。

 也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

2、泛型好处

提高安全性(将运行期的错误转换到编译期) 

 省去强转的麻烦

3、泛型基本使用

<>中放的必须是引用数据类型 

4、泛型使用注意事项

前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

二、泛型类：泛型定义在类上

定义格式

public class 类名<泛型类型1,…>

泛型类型必须是引用类型

三、泛型方法：把泛型定义在方法上

定义格式

public <泛型类型> 返回类型 方法名(泛型类型 变量名)

四、泛型接口：把泛型定义在接口上

定义格式

      public interface 接口名<泛型类型>

五、泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了

1、? extends E

向下限定，E及其子类

2、? super E

向上限定，E及其父类

六、增强for：简化数组和Collection集合的遍历

for(元素数据类型 变量 : 数组或者Collection集合) {

使用变量即可，该变量就是元素

}

七、静态导入概述

import static 包名….类名.方法名;

可以直接导入到方法的级别

注意事项：方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。

由此可见，意义不大，所以一般不用，但是要能看懂

八、可变参数：定义方法的时候不知道该定义多少个参数

格式

修饰符 返回值类型 方法名(数据类型…  变量名){}

注意事项：

这里的变量其实是一个数组

如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Iterator;

public class Generic {
	public static void main(String[] args) {
		/*
		 * 一、泛型概述和基本使用
		    1、泛型的由来:通过Object转型问题引入
				早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
			  也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
		 	2、泛型好处
	 			提高安全性(将运行期的错误转换到编译期) 
				省去强转的麻烦
			3、泛型基本使用
				<>中放的必须是引用数据类型 
			4、泛型使用注意事项
				前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
		   二、泛型类：泛型定义在类上
			  定义格式
				 	public class 类名<泛型类型1,…>
			    		泛型类型必须是引用类型
		   三、泛型方法：把泛型定义在方法上
			  定义格式	
					public <泛型类型> 返回类型 方法名(泛型类型 变量名)
		   四、泛型接口：把泛型定义在接口上
			  定义格式	
					public interface 接口名<泛型类型>
		   五、泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了
			 1、? extends E
					向下限定，E及其子类
			 2、? super E
					向上限定，E及其父类
		   六、增强for：简化数组和Collection集合的遍历
				  for(元素数据类型 变量 : 数组或者Collection集合) {
						使用变量即可，该变量就是元素
				  }
		   七、静态导入概述
				 import static 包名….类名.方法名;
				 可以直接导入到方法的级别
			  注意事项
				 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。
				 由此可见，意义不大，所以一般不用，但是要能看懂
		   八、可变参数：定义方法的时候不知道该定义多少个参数
			  格式
				 修饰符 返回值类型 方法名(数据类型…  变量名){}
			  注意事项：
				 这里的变量其实是一个数组
				 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
		 * */
		initGeneric();
		genericCome();
		
		addFor();//for增强
		removeFor();
		arrayToList();//数组转集合
		forFor();//嵌套循环
	}

	private static void forFor() {
		ArrayList<ArrayList<Student>> list = new ArrayList<>();
		
		ArrayList<Student> firstClass = new ArrayList<>();
		firstClass.add(new Student("利达",17));
		firstClass.add(new Student("利二",18));
		firstClass.add(new Student("利三",19));
		
		ArrayList<Student> secondClass = new ArrayList<>();
		secondClass.add(new Student("益达",17));
		secondClass.add(new Student("益二",18));
		secondClass.add(new Student("益三",19));
		
		list.add(firstClass);
		list.add(secondClass);
		
		for(ArrayList<Student> newClass :list){
			for(Student s : newClass){
				System.out.println(s);
			}
		}
	}

	/*
	 * 数组转换成集合
	 * 数组转换成集合不能增加或减少元素，但是可以使用集合的思想操作数组，即可以使用其它集合中的方法
	 * */
	private static void arrayToList() {
		System.out.println("===========数组转集合===========");
		String[] sA = {"a","b","c","d"};
		List<String> list = (List<String>) Arrays.asList(sA);
		System.out.println(list);
	}

	private static void removeFor() {
		System.out.println("===========for删除===========");
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		
//		//1、for删除
//		for (int i = 0; i < list.size(); i++) {
//			if("b".equals(list.get(i))){
//				list.remove(i--);
//			}
//		}
		
		//2、迭代器删除
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			if("b".equals(it.next())){
//				list.remove(it.next());   
				/*java.util.ConcurrentModificationException并发修改异常
				  不能使用集合的方法删除，因为迭代过程中如果修改就出现并发修改异常
				 */
				it.remove();//使用迭代器本身的方法
			}
		}
		
//		//3、增强for循环
//		for (String string : list) {
//			if("b".equals(string)){
//				list.remove("b");     //增强for循环只能遍历不能删除
//			}
//		}
		System.out.println(list);
	}

	//for增强
	private static void addFor() {
		int[] arr = {11,22,33,44,55};
		for (int i : arr){
			System.out.print(i + " ");
		}
		System.out.println();
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		for (String string : list) {
			System.out.print(string + " ");
		}
		System.out.println();
	}

	private static void genericCome() {
		Tool<GirlStudent> t = new Tool<>();
		t.setObj(new GirlStudent("花季",16));
		
		//java.lang.ClassCastException  类转换异常
//		BoyStudent bs = (BoyStudent) t.getObj();
		GirlStudent gs = t.getObj();
		
		Tool<String> t1 = new Tool<>();
		t1.show("abc");
	}

	private static void initGeneric() {
		ArrayList<Student> arrList = new ArrayList<Student>();
		arrList.add(new Student("王二",18));
		arrList.add(new Student("张三",22));
		arrList.add(new Student("李四",20));
		arrList.add(new Student("赵六",16));
		
		Iterator<Student> it = arrList.iterator();
		while(it.hasNext()){
			//next方法只能调用一次，如果调用多次就会将指针向后移动多次;因此创建一个对象指向next获取的对象
//			System.out.println(it.next().getName() + "--" + it.next().getAge());
			Student s = it.next();
			System.out.println(s.getName() + "--" + s.getAge());
		}
	}
}

interface Inter<T>{
	public void show(T t);
}

class Demo implements Inter<String>{     //推荐使用这种方法
	public void show(String s){
		System.out.println(s);
	}
}

//class Demo<T> implements Inter<String>{    //实现接口时没必要对自己添加一个泛型
//	public void show(String s){
//		System.out.println(s);
//	}
//}

泛型

//<一个大写字母>代表泛型
public class Tool<E> {
	private E obj;

	public E getObj() {
		return obj;
	}

	public void setObj(E obj) {
		this.obj = obj;
	}
	
	public<T> void show(T t){      //非静态方法泛型最好与类泛型一致
		System.out.println(t);    //如果不一致，最好在方法上声明该泛型;使用时传具体的值
	}
	
	public static<Q> void print(Q q){   //静态方法必须声明自己的泛型
		System.out.println(q);
	}
}