String_SE day14 泛型***

一泛型
1 泛型就是 集合里面规定存储的数据类型，类似与数组一样，int [] 数组只能存储int类型的数组，
格式 实例： Collection c=new ArrayList();
当然 泛型是引用类型，如果想存储整数类型，泛型是Integer ，在add（）方法时候，可以直接加入10，如 c.add(10);因为 有自动拆装箱
2 * 泛型好处:
* 1)将运行时期异常提前到了编译时期
* 2)解决了黄色警告线问题
* 3)获取数据的时候,不用强制类型转换了
* 泛型的应用:
* 一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!
3 将泛型定义在类上
*

// 将泛型定义在类上，

/* * 将泛型定义在类上面（这时候何集合没有什么练习，只是规定该类在创建new的时候是什么类型） * 以后关于T t的变量 t所指向的变量就是规定（初始化类时候制定的类型）的引用类型 */public class ClassFan<T  > { private T obj;public ClassFan() {    super();    // TODO 自动生成的构造函数存根}public ClassFan(T obj) {    super();    this.obj = obj;}public T getObj() {    return obj;}public void setObj(T obj) {    this.obj = obj;}}

/* * 创建ClassFan<T  > 具体的类型即 指明T的类型 */public class TestClassFan {    public static void main(String[] args) {        // TODO 自动生成的方法存根        //指明T是String        ClassFan<String  >  cf1=new ClassFan<String  > ("hello");        System.out.println(cf1.getObj());// hello        //指明T是 Student类型        Student s=new Student("王帅",20);        Student s2=new Student("王帅",30);        ClassFan<Student >  cf2=new ClassFan<Student  >();        cf2.setObj(s);        System.out.println(cf2.getObj());        cf2.setObj(s2);        System.out.println(cf2.getObj());        //结果 分别打印 两次学生的信息 Student类重写了toString()方法        //这时候ClassFan<T  > 就好像是一个集合一样，        //可以存储指定类型，对象cf2就可以收集两个学生信息    }}

public class Student {    private String name ;    private int age ;    public Student() {        super();        // TODO Auto-generated constructor stub    }    public Student(String name, int age) {        super();        this.name = name;        this.age = age;    }    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;    }    @Override    public String toString() {        return "Student [name=" + name + ", age=" + age + "]";    }}

4 将泛型定义在方法上面

/* * 泛型定义在方法上面 * 就要在方法的上面统一类似声明一下<T> *  public<T> void show(T t){     System.out.println(t);    } */public class ObjcetToolDemo2 { public<T> void show(T t){     System.out.println(t); }  private void mian() {      ObjcetToolDemo2 odt1=new ObjcetToolDemo2();      odt1.show("hello word");// hello }}

5将泛型定义在接口上面

情况1 在子类去实现的时候 再明确接口的类型//定义一个泛型接口//其实如果接口有参数，有几个类同时要实现该接口，泛型接口比较方便public interface F<T> {   public abstract void show(T t);}-------------------------------------//定义子实现类 明确自己是Sting类型    //所以 在下面的一行 接口要写上明确的类型  //所以接口对应的方法 重写的时候也要指明具体的类型public class Fimpl implements F<String>{    public static void main(String[] args) {        // TODO 自动生成的方法存根        Fimpl fp=new Fimpl();        fp.show("hello");    }    @Override    public void show(String t  ) {        、        System.out.println(t);    }}

/* * 第二种情况 * 子类自己在定义类实现时候，也不知道自己需要上面类型，只有在new 类的时候才想好, * 所以也要在该类后面添加泛型 */public class Fanimpl2<T>implements F<T>{    public static void main(String[] args) {        // TODO 自动生成的方法存根        Fanimpl2<String> fl=new Fanimpl2<String>();//创建实例的时候指明类型        fl.show("hello");    }    @Override    public void show(T t) {        // TODO 自动生成的方法存根        System.out.println(t);    }}

6泛型通配符

• 泛型的高级:通配符

实例  利用增强for循环迭代遍历（二重遍历）import java.util.ArrayList;public class ArrayListDemo1 {    /**     * 双重迭代  集合嵌套     * ArrayList<ArrayList<Person>> aap=new ArrayList();     */    public static void main(String[] args) {        Person p1=new Person("李明1","1");        Person p2=new Person("李明2","2");        Person p3=new Person("李明3","3");        Person p4=new Person("李明4","4");        Person p5=new Person("李明5","5");        //ArrayList 里面添加学生        ArrayList<Person> ap1=new ArrayList();        //ap1 添加 两个学生         ap1.add(p1);        ap1.add(p2);        //泛型是集合         ArrayList<Person> ap2=new ArrayList();        //ap2添加两个学生        ap2.add(p3);        ap2.add(p4);        //ap3添加两个学生        ArrayList<Person> ap3=new ArrayList();        ap3.add(p5);        //集合里面存取集合        ArrayList<ArrayList<Person>> aap=new ArrayList();        aap.add(ap1);        aap.add(ap2);        aap.add(ap3);        //首先从aap里面取到的数据也是一个集合        for(ArrayList<Person> al:aap){            //便利取到的集合 这次取到的是person类            System.out.println(al.size());            for(Person p: al)                System.out.println(p);    }    }}

应用 1 ArrayList去除集合中字符串的重复值(字符串的内容相同)

public class ClassDemo {    /** ArrayList去除集合中字符串的重复值(字符串的内容相同)     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub             ArrayList<String> al=new ArrayList();             al.add("hello");    //0             al.add("java");         //1             al.add("hello");    //2             al.add("hello");   //3             al.add("java");   //4             al.add("javaEE");           for(int i=0;i<al.size()-1;i++)               for(int j=i+1;j<al.size();j++){                   if(al.get(i).equals(al.get(j))){                       al.remove(j);                       //j-- 原因 :                       //因为删除了 下表为2 的元素 hello所以                       // 下一个元素自动成为第二个元素  所以要再次判断 该下表的元素 ，不然如果下一个元素                      // 即使重复也不会删除了                      /*                        * 没有j--                       * 输出结果：                       hello                       java                       hello                       javaEE                          */                       j--;                   }               }               //System.out.println(al.size());           for(String s:al)               System.out.println(s);    }}

应用2：需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同)

/** *  需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同) *   *  发现问题: *          使用刚才创建新集合的思想,逻辑步骤和去除集合中重复的字符串是一样,但是出现了并没有将自定义对象的重复值(成员变量值一样)并没有去除掉 *   *          contains()底层依赖于一个equals()方法,equals()方法是Object类的中的方法,该法默认比较的是对象的地址值是否相同,必须要重写Object中的eqauls() *  方法,才能比较内容是否相同; *          在自定义对象的类中重写Object中的equasl()方法,才能比较成员变量的值是否相同 *  看源码: *   *          ArrayList集合的Contains()源码 *            public boolean contains(Object o) {                return indexOf(o) >= 0;    }    public int indexOf(Object o) {        if (o == null) {            for (int i = 0; i < size; i++)                if (elementData[i]==null)                    return i;        } else {            for (int i = 0; i < size; i++)                if (o.equals(elementData[i]))                    return i;        }        return -1;    } *   * @author Apple */public class ArrayListTest3 {    public static void main(String[] args) {        //创建一个ArrayList集合对象        ArrayList array = new ArrayList() ;        //2)创建学生对象        Student s1 = new Student("高圆圆", 27) ;        Student s2 = new Student("高圆圆", 20) ;        Student s3 = new Student("邓超", 29) ;        Student s4 = new Student("邓超", 25) ;        Student s5 = new Student("黄晓明", 30) ;        Student s6 = new Student("高圆圆", 27) ;        //将学生对象添加到array集合中        array.add(s1) ;        array.add(s2) ;        array.add(s3) ;        array.add(s4) ;        array.add(s5) ;        array.add(s6) ;        //3)创建一个新集合        ArrayList newArray = new ArrayList() ;        //遍历旧集合,获取迭代器对象        Iterator it = array.iterator() ;        while(it.hasNext()){            Student s = (Student) it.next() ;            //判断新集合中是否包含这些对象            if(!newArray.contains(s)){                //不包含的对象才能添加新集合                newArray.add(s) ;            }        }        //遍历新集合        Iterator it2 = newArray.iterator() ;        while(it2.hasNext()){            Student s = (Student) it2.next() ;            System.out.println(s.getName()+"---"+s.getAge());        }    }}注意：Student类要重写equals()方法：public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        Student other = (Student) obj;        if (age != other.age)            return false;        if (name == null) {            if (other.name != null)                return false;        } else if (!name.equals(other.name))            return false;        return true;    }

三list集合特点
List集合的子实现类的特点:

ArrayList:        底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢        从线程安全问题来看:线程不安全的,不同步,执行效率高Vector:        底层数据结构是数组的形式,查询快,增删慢        从线程角度看:线程安全的类,同步,执行效率低LinkedList:        底层数据结构是链接列表,特点:查询慢,增删快        从线程角度看:线程不安全的一个类,不同步,执行效率高        如果实现多线程程序,一般要是安全的类:                StringBuffer,Vector<E>,hashtable<K,V>                synchronized(同步锁对象){                    代码;                }    如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList    如果需求中要考虑线程安全,那么使用Vector集合!        笔试过程中,一些需求用到集合:就是用ArrayList

四LinkedList

import java.util.LinkedList;/** * LinkedList:            底层数据结构是链接列表,特点:查询慢,增删快            从线程角度看:线程不安全的一个类,不同步,执行效率高    特有功能:        添加功能:            public void addFirst(E e)将指定元素插入此列表的开头。            public void addLast(E e)将指定元素添加到此列表的结尾。        获取功能:            public Object getFirst()返回此列表的第一个元素            public Object getLast()返回此列表的最后一个元素。        删除功能:            public Object removeFirst()移除并返回此列表的第一个元素。            public Object removeLast()移除并返回此列表的最后一个元素。 * @author Apple */public class LinkedListDemo {    public static void main(String[] args) {        //创建LinkedList集合        LinkedList link = new LinkedList() ;        //添加元素        link.addFirst("hello") ;        link.addFirst("world") ;        link.addFirst("Java") ;        //public void addFirst(E e)将指定元素插入此列表的开头        /*link.addFirst("android") ;        link.addLast("JavaWeb") ;*/        /**         * public Object getFirst()返回此列表的第一个元素            public Object getLast()返回此列表的最后一个元素。         */        /*        Object obj = link.getFirst() ;        System.out.println(obj);        Object obj2 = link.getLast() ;        System.out.println(obj2);*/        /**         * public Object removeFirst()移除并返回此列表的第一个元素。            public Object removeLast()移除并返回此列表的最后一个元素。         */        /*System.out.println("removeFirst:"+link.removeFirst());        System.out.println("removeLast:"+link.removeLast());*/        //输出集合        System.out.println("link:"+link);    }}

LinkedList练习
练习1：
需求:使用LinkedList模拟一个栈结构的特点
表达的意思:自定义栈集合类,然后使用LinkedList的一些特有功能模拟栈结构特点

public class LinkedListDemo {    public static void main(String[] args) {        //创建LinkedList集合的对象        LinkedList link = new LinkedList() ;        //LinkedList集合的特有功能:addFirst(Object e)         //栈结构的特点:先进后出        link.addFirst("hello") ;        link.addFirst("world") ;        link.addFirst("java") ;//注意：java成为第一个元素        Iterator it = link.iterator() ;        while(it.hasNext()){            String s = (String)it.next() ;            System.out.println(s);        }    }}

模拟栈结构

/** * 自定义的栈集合类 * @author Apple */public class MyStack {    //成员变量    private LinkedList link ;    //无参构造    //通过无参进行LinkedList集合对象 的创建    public MyStack(){        link = new LinkedList() ;    }    //添加功能    public void add(Object obj){        link.addFirst(obj) ;//向集合中列表插入到第一个元素    }    //获取功能    public Object get(){        return link.removeFirst() ;//删除集合列表中的第一个元素,返回值是被删除的元素    }    //定义判断集合是否为空    public boolean isEmpty(){        return link.isEmpty() ;    }}------------------------/** * 自定义栈集合的测试类 * @author Apple */public class MyStackDemo {    public static void main(String[] args) {        //创建自定义栈集合类的对象        MyStack ms = new MyStack() ;        //调用添加功能        ms.add("hello") ;//link.addFier("hello")        ms.add("world") ;        ms.add("java") ;        //当前栈集合中有元素了        //获取集合集合中的元素    /*  System.out.println(ms.get());        System.out.println(ms.get());        System.out.println(ms.get());        //java.util.NoSuchElementException:没有这样元素的异常        System.out.println(ms.get());*/        //给当前集合对象来判断:判断集合是否为空        /*if(!ms.isEmpty()){            System.out.println(ms.get());        }*/        while(!ms.isEmpty()){            System.out.println(ms.get());        }    }}