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);}}