java学习第十八天之泛型、ArrayList、TreeSet、HashSet、泛型方法，泛型接口、泛型类、泛型的限定

最新推荐文章于 2021-03-01 21:14:32 发布

MiracleBubble

最新推荐文章于 2021-03-01 21:14:32 发布

阅读量395

点赞数

本文链接：https://blog.csdn.net/weiyumeizi/article/details/64905397

版权

package cncollectionframe.demo;

import java.util.Comparator;

public class ComparatorByLength implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
//      对字符串按照长度比较
        String string1=(String)o1;
        String string2=(String)o2;
//      比较长度
        int temp = string1.length()-string2.length();
//      长度相同，再按字典排序
        return temp==0?string1.compareTo(string2):temp;
    }

}


package cncollectionframe.demo;

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

/**
 * @author john5
 *
 */
public class GenericDemo {
    /**
    * @param args
    * 泛型：
    * 在JDK1.4版本之前，容器什么类型的对象都可以存储，但是在取出时，需要用到对象的特有内容是，需要向下转型
    * 但是对象的类型不一致，导致了向下转型是发生了ClassCastException异常
    * 为了避免这个问题，只能主观上控制，往集合中存储的对象类型保持一致
    * 
    * JDK1.5以后解决了这个问题，在定义集合时，就明确集合中存储元素的具体类型
    * 这样，编译器在编译时，就可以对集合中存储的对象类型进行检查。
    * 一旦发现类型不匹配，就编译失败，这个技术就是泛型技术
    * 
    * 好处：
    *   1、将运行时期的问题转移到编译时期，可以更好的让程序员发现问题并解决问题
    *   2、避免了向下转型的麻烦
    * 
    * 总结：泛型就是应用在编译时期的一项安全机制
    * 
    * 泛型的擦除：编译器通过泛型对元素类型进行检查，只要检查通过，
    * 就会生成class文件，但在class文件中，就将泛型标识去掉了。
    * 泛型的表现：泛型技术在集合框架中应用的范围很大。什么时候需要些泛型呢？
    *   1、只要看到类，或者接口在描述时的右边定义<>，就需要泛型
    * 其实是，容器在不明确操作元素的类型的情况下，对外提供了一个参数<>
    * 使用容器时，只要将具体的类型实参传递给该参数即可
    * 说白了，泛型就是，传递类型参数
    */
    public static void main(String[] args) {
//      为了运行时期不出现类型异常，可以在定义类型时，就明确容器中的元素类型
//      List<String> list=new ArrayList<String>();
        List list =new ArrayList();
        list.add("adsa");
        list.add(4);

        for (Iterator iterator = list.iterator(); iterator.hasNext();) {
//          Object object=iterator.next();
            String string=(String)iterator.next();
            System.out.println(iterator.next().toString());
            System.out.println(string.length());
        }
        /*
        给Iterator加上泛型，就不用再强转
        for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
            String string=iterator.next();
            System.out.println(string.length());
        }
        */
    }
}

package cncollectionframe.demo;

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

public class GenericDemo2 {

    public static void main(String[] args) {
//      创建一个list集合  存储一个整数 List ArrayList
        List<String> list=new ArrayList<String>();
        List<Integer> list1=new ArrayList<Integer>();
        list.add("fff");
        System.out.println(list);
        list1.add(555);
        System.out.println(list1);
        for (Iterator<Integer> iterator = list1.iterator(); iterator.hasNext();) {
            Integer integer = (Integer) iterator.next();
            System.out.println(integer);
        }
    }
}

package cncollectionframe.demo;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class GenericDemo3 {
    public static void main(String[] args) {
        Set<String> set =new TreeSet<String>(); 
//      Set<Person> set2 =new TreeSet<Person>();    
        Set<Person> set2=new HashSet<Person>();//重写hasCode()方法和equals()方法去冗
        set.add("23");
        set.add("forjf");
        set.add("asds");
        set2.add(new Person("sdfs",39));
        set2.add(new Person("seres",32));
        set2.add(new Person("adsdfs",13));
        set2.add(new Person("sdfs",39));
        set.add(set2.toString());
        for(String s:set){
            System.out.println(s);
        }

        for(Person s:set2){
            System.out.println(s);
        }
    }   
}

package cncollectionframe.demo;

import cn.myarraylist.domain.Student;

public class GenericDemo4 {
    /**
    * @param args
    */
    public static void main(String[] args) {
        Tool tool=new Tool();
        tool.setObject(new Student());
        Student stduent=(Student)tool.getObject();

        /*定义泛型类，传参数
         * Util<Student> util=new Util<Student>();
        util.setObject(new Worker());//如果类型不匹配，直接编译失败
        Student student=util.getObject();//避免了向下转型
        System.out.println(student);*/
    }
}

/*class Tool{

    创建一个用于操作Student对象的工具类。对对象进行设置和获取
    太有局限性了，可不可以定义一个可以操作所有对象的工具呢？
    类型向上抽取,当要操纵的对象不确定的时候，为了扩展，可以使用Object类型来完成
    但是这种方式会出现一种小弊端，会出现转型，向下转型容易在运行时出现ClassCastException

    jdk1.5以后，出现新的解决方案
    类型不确定时，可以对外提供参数，用使用者通过传递参数的形式完成类型的确定

    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}*/
class Tool{
    private Object object;

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }

}

//在类定义时就传递擦拿书，由使用该类的调用者，来传递具体的类型
class Util<W>{//泛型类，类上多了参数
    private W object;

    public W getObject() {
        return object;
    }

    public void setObject(W object) {
        this.object = object;
    }
}

package cncollectionframe.demo;

public class GenericDemo5 {
    public static void main(String[] args) {
        Demo<String> demo= new Demo<String>();
        demo.show("123324");
//      demo.print(5);//类型不对应
        Demo<Integer> demo2=new Demo<Integer>();
        demo2.print(5);
//      demo2.show("123324");//类型不对应
        Demo<String> demo3= new Demo<String>();
        demo3.clear(123);//调用 泛型方法
        demo3.clear("spring");
    }
}

泛型方法

package cncollectionframe.demo;

public class GenericDemo5 {
    public static void main(String[] args) {
        Demo<String> demo= new Demo<String>();
        demo.show("123324");
//      demo.print(5);//类型不对应
        Demo<Integer> demo2=new Demo<Integer>();
        demo2.print(5);
//      demo2.show("123324");//类型不对应
        Demo<String> demo3= new Demo<String>();
        demo3.clear(123);//调用 泛型方法
        demo3.clear("spring");
    }
}

class Demo<W>{
    public static<A> void staticShow(A w) {//静态方法是无法访问类上定义的泛型的。如果静态方法需要定义泛型，泛型只能定义在方法上
        System.out.println("show:"+w);
    }
    public void show(W w) {
        System.out.println("show:"+w);
    }
    public void print(W w) {
        System.out.println("print"+w);
    }
    public <Q> void clear(Q w) {//泛型方法
        System.out.println("clear:"+w);
    }
}

泛型接口

package cncollectionframe.demo;

public class GenericDemo6 {
    public static void main(String[] args) {
        SubDemo subDemo=new SubDemo();
        subDemo.show("123");
    }
}

interface Inter<T>{//泛型接口
    public void show(T t);
}

class InterImpl<String> implements Inter<String>{
    @Override
    public void show(String t) {
    }
}

class InterImpl2<W> implements Inter<W>{

        @Override
    public void show(W t) {
            System.out.println(t);
    }   
}

class SubDemo extends InterImpl2<String>{

}

泛型的限定

package cncollectionframe.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class GenericDemo7 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("sdsd");
        list.add("sdsddd");
        list.add("123");
//      printCollection(list);

        Set<String> set=new HashSet<String>();
        set.add("sdsd");
        set.add("sdsddd");
        set.add("123");
//      printCollection(set);

        List<Student> list2=new ArrayList<Student>();
        list2.add(new Student("sdsd",24));
        list2.add(new Student("sdsddd",12));
        list2.add(new Student("123",56));
        printCollection(list2);


        Set<Worker> set2=new HashSet<Worker>();
        set2.add(new Worker("sdsd",24));
        set2.add(new Worker("sdsddd",12));
        set2.add(new Worker("123",56));
        printCollection(set2);
    }

    /**
     * @param 用于 list 和 set
     */
    /*private static void printCollection(Collection<String> collection) {
        for (Iterator<String> iterator = collection.iterator(); iterator.hasNext();) {
            String string = iterator.next();
            System.out.println(string);

        }
    }*/

    /**
     * @param 用于 list 和 set 和list2
     */
    /*private static void printCollection(Collection<?> collection) {//在不明确类型的情况下，可以用通配符表示
        for (Iterator<?> iterator = collection.iterator(); iterator.hasNext();) {
            Object object = iterator.next();
            System.out.println(object);

        }
    }*/

    /**
     * @param 用于 list2 和set2
     * 泛型的限定
     *  ? extends E:接受E类型或者E的子类型   ？extends Person:泛型上限
     * ? super E :接受E类型或者是E的父类型    ？super Student：泛型的下限（下面被限制住）
     */
    private static void printCollection(Collection<? extends Person> collection) {
        for (Iterator<?> iterator = collection.iterator(); iterator.hasNext();) {
            Object object = iterator.next();
            System.out.println(object);

        }
    }
}

package cncollectionframe.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo8 {
    public static void main(String[] args) {
        /*
        演示泛型限定在api中的体现
        TreeSet的构造函数
        TreeSet(Collection <? extends E> collection);
        什么时候会用到上限呢？
        一般往集合存储元素时，如果集合 定义了E类型通常情况下应该存储E类型的对象
        对E的子类型的对象E类型也可以接受，所以这是可以将泛型从E改为 ？ extends E

        什么时候会用到下限呢？
        */


        /*Collection collection=new ArrayList();
        collection.add("1223");
        collection.add("asss");*/

        Collection<Student> collection=new ArrayList<Student>();        
        collection.add(new Student("sdsd",24));
        collection.add(new Student("sdsddd",12));
        collection.add(new Student("123",56));

//      TreeSet treeSet=new TreeSet<>();
//      treeSet.add("wei");
        TreeSet<Integer> treeSet=new TreeSet<Integer>();
        treeSet.add(123);

        TreeSet<Person> treeSet2=new TreeSet<Person>(collection);
        treeSet2.add(new Person("Bubble",23));
        treeSet2.add(new Worker("Bubble",23));


        for (Iterator<Person> iterator = treeSet2.iterator(); iterator.hasNext();) {
            Person person = iterator.next();
            System.out.println(person.getName());
        }
    }
}
class MyTreeSet<E>{
    public MyTreeSet() {

    }
    /*和下面的方法相同
    public MyTreeSet(Collection collection) {

    }
    */
    public MyTreeSet(Collection<? extends E> collection) {

    }
}

package cncollectionframe.demo;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo9 {
    /*
    演示泛型限定在api中的体现
    TreeSet的构造函数
    TreeSet(Collection <? extends E> collection);

    什么时候会用到下限呢？
    当从容器中取出元素操作时，可以用E类型接受，也可以用E的父类型接收
    */
    public static void main(String[] args) {
//创建一个比较器
        Comparator<Person> comparator=new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                int temp=o1.getAge()-o2.getAge();
                return temp==0?o1.getName().compareTo(o2.getName()):temp;
            }

        };

        TreeSet<Student> students=new TreeSet<Student>(comparator);
        students.add(new Student("sdsd",24));
        students.add(new Student("sdsddd",12));
        students.add(new Student("123",56));

        TreeSet<Worker> student=new TreeSet<Worker>(comparator);
        student.add(new Worker("resd",24));
        student.add(new Worker("hnhsddd",12));
        student.add(new Worker("hn3",56));

        for (Iterator<Student> iterator = students.iterator(); iterator.hasNext();) {
            Person person = iterator.next();
            System.out.println(person.getName());
        }
    }
}

class YouTreeSet<E>{
    /**
     * 
     */
    public YouTreeSet(Comparator<? super E> comparator) {
        // TODO Auto-generated constructor stub
    }   
}

package cncollectionframe.demo;

public class Person implements Comparable<Person> { 
    private String name;
    private int age;

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
    }

    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 int compareTo(Person o) {
        int temp=this.age=o.age;

        return temp==0?this.name.compareTo(o.name):temp;
    }
    /**
    * @param args
    */

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
    final int NUMBER=38;
    return this.name.hashCode()+age*NUMBER;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if(!(obj instanceof Person)){
            throw new ClassCastException();
        }
        Person person=(Person)obj;
        return this.name.equals(person.name) && this.age== person.age;
    }
}

package cncollectionframe.demo;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StringDemo_1 {
    /**
    * @param对多个字符串（不重复）按照长度排序（由长到短）
    */
    public static void main(String[] args) {
//      sortStringByLength();
        sortStringByLength2();
    }
    public static void sortStringByLength() {
        Set set= new TreeSet(new ComparatorByLength());//自妇产按长度排序的方式
        set.add("sdsu");
        set.add("abcd");
        set.add("DFFFFFF");
        set.add("ADEF");
        for(Object object:set){
            System.out.println(object);
        }
    }

//  对多个字符串（重复），按照长度排序
    public static void sortStringByLength2() {
        String[] strings={"sdfsdf","sdfdfsf","acsddsd"};
        /*
        自然排序可以使用String类中的compareTp方法
        但是现在要的是长度排序，这就需要比较器
        */
        Comparator comparator= new ComparatorByLength();

//      排序需要嵌套循环。位置置换
        for(int x=0,end=strings.length;x<end;x++){
            for(int y=x+1;y<strings.length;y++){
                if (comparator.compare(strings[x],strings[y])>0) {//按照长度排序
                    swap(strings,x,y);
                }   
            }
        }
        /*
//      排序需要嵌套循环。位置置换
        for(int x=0,end=strings.length;x<end;x++){
            for(int y=x+1;y<strings.length;y++){
                if (strings[x].compareTo(strings[y])>0) {//按照字典排序
                    swap(strings,x,y);
                }   
            }
        }
        */
        for(String s:strings){
            System.out.println(s);          
        }

    }
    /**
     * @param strings
     * @param x
     * @param y
     */
    private static void swap(String[] strings, int x, int y) {
        String temp=strings[x];
        strings[x]=strings[y];
        strings[y]=temp;
    }
}

package cncollectionframe.demo;

public class Student extends Person{

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super(name, age);

    }

    @Override
    public String toString() {
        return "Stduent [getName()=" + getName() + ", getAge()=" + getAge() + ", toString()=" + super.toString() + ", hashCode()=" + hashCode() + ", getClass()=" + getClass() + "]";
    }

}

package cncollectionframe.demo;

public class Worker extends Person {

    @Override
    public String toString() {
        return "Worker [getName()=" + getName() + ", getAge()=" + getAge() + ", toString()=" + super.toString() + ", hashCode()=" + hashCode() + ", getClass()=" + getClass() + "]";
    }

    public Worker() {
        super();
    }

    public Worker(String name, int age) {
        super(name, age);
    }


}

MiracleBubble

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java学习第十八天之泛型、ArrayList、TreeSet、HashSet、泛型方法，泛型接口、泛型类、泛型的限定

package cncollectionframe.demo;import java.util.Comparator;public class ComparatorByLength implements Comparator { @Override public int compare(Object o1, Object o2) {// 对字符串按照长度比较
复制链接

扫一扫