黑马程序员_Java基础_集合框架2

来源：互联网发布：java高级架构师视频编辑：程序博客网时间：2024/04/25 12:28

一、集合框架(TreeSet)

[java] view plaincopy
/* 
Set:无序，不可重复元素。 
    |--HashSet:数据结构是哈希表。线程是非同步的。 
               保证元素唯一性的原理：判断元素的hashCode值是否相同。 
               如果相同，还会继续判断元素的equals方法，是否为true。 
    |--TreeSet:可以对Set集合中的元素进行排序。 
*/  
import java.util.*;  
class TreeSetDemo   
{  
    public static void main(String[] args)   
    {  
        TreeSet ts=new TreeSet();  
        ts.add("cba");  
        ts.add("abcd");  
        ts.add("aaa");  
        ts.add("bca");  
  
        Iterator it=ts.iterator();  
        while(it.hasNext())  
        {  
            System.out.println(it.next());  
        }  
    }  
}  

二、集合框架(TreeSet存储自定义对象)

[java] view plaincopy
/* 
Set:无序，不可重复元素。 
    |--HashSet:数据结构是哈希表。线程是非同步的。 
               保证元素唯一性的原理：判断元素的hashCode值是否相同。 
               如果相同，还会继续判断元素的equals方法，是否为true。 
    |--TreeSet:可以对Set集合中的元素进行排序。 
 
需求： 
往TreeSet集合中存储自定义对象，按照学生的年龄进行排序。 
 
注意：排序时。当主要条件相同时，一定要再判断次要条件。 
*/  
import java.util.*;  
class Student implements Comparable//该接口强制让学生具备比较性  
{  
    private String name;  
    private int age;  
    public int compareTo(Object obj)//覆盖compateTo  
    {  
        if(!(obj instanceof Student))  
            throw new RuntimeException("不是学生对象");  
        Student s=(Student)obj;  
          
        System.out.println(this.name+"...compateTo...."+s.name);  
        if(this.age>s.age)  
            return 1;//返回正数  
  
        if(this.age==s.age)  
        {  
            return this.name.compareTo(s.name);//判断次要条件。调用String类compareTo  
        }  
        return -1;  
    }  
    Student(String name,int age)  
    {  
        this.name=name;  
        this.age=age;  
    }  
    public String getName()  
    {  
        return name;  
    }  
    public int getAge()  
    {  
        return age;  
    }  
}  
class TreeSetDemo   
{  
    public static void main(String[] args)   
    {  
        TreeSet ts=new TreeSet();  
        ts.add(new Student("lisi02",22));  
        ts.add(new Student("lisi007",19));  
        ts.add(new Student("lisi09",19));  
        ts.add(new Student("lisi01",40));  
  
        Iterator it=ts.iterator();  
        while(it.hasNext())  
        {  
            Student st=(Student)it.next();  
            System.out.println("姓名："+st.getName()+"\t年龄："+st.getAge());  
        }  
    }  
}  

三、集合框架(二叉树)

[java] view plaincopy
/* 
Set:无序，不可重复元素。 
    |--HashSet:数据结构是哈希表。线程是非同步的。 
               保证元素唯一性的原理：判断元素的hashCode值是否相同。 
               如果相同，还会继续判断元素的equals方法，是否为true。 
    |--TreeSet:可以对Set集合中的元素进行排序。 
                底层数据结构是二叉树。 
                保证元素唯一性的依据： 
                compareTo方法 return 0; 
 
                TreeSet排序的第一种方式： 
                让元素自身具有比较性。元素需要实现compareTo方法，这种方式也成为 
                元素的自然顺序，也叫默认顺序。 
　　TreeSet排序的第二种方式： 
　　当元素自身不具有比较性，或者具备的比较性不是所需要的。这时就需要 
　　让集合自身具有比较性。就是在集合初始化时就有了比较方式。 
 
需求： 
往TreeSet集合中存储自定义对象，按照学生的年龄进行排序。 
 
注意：排序时。当主要条件相同时，一定要再判断次要条件。 
*/  
import java.util.*;  
class Student implements Comparable//该接口强制让学生具备比较性  
{  
    private String name;  
    private int age;  
    public int compareTo(Object obj)//覆盖compateTo  
    {  
        return 1;//怎么存怎么取。保证始终存入的要比前一个大。  
    }  
    Student(String name,int age)  
    {  
        this.name=name;  
        this.age=age;  
    }  
    public String getName()  
    {  
        return name;  
    }  
    public int getAge()  
    {  
        return age;  
    }  
}  
class TreeSetDemo   
{  
    public static void main(String[] args)   
    {  
        TreeSet ts=new TreeSet();  
        ts.add(new Student("lisi02",22));  
        ts.add(new Student("lisi007",19));  
        ts.add(new Student("lisi09",19));  
        ts.add(new Student("lisi01",40));  
  
        Iterator it=ts.iterator();  
        while(it.hasNext())  
        {  
            Student st=(Student)it.next();  
            System.out.println("姓名："+st.getName()+"\t年龄："+st.getAge());  
        }  
    }  
}  

四、集合框架(实现Comparator方式排序)

[java] view plaincopy
/* 
当元素自身不具有比较性，或者具备的比较性不是所需要的。这时就需要 
让集合自身具有比较性。就是在集合初始化时就有了比较方式。 
定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。 
 
当两种排序都存在时，以比较器为主。 
 
定义一个类，实现Comparator接口，覆盖compare方法。 
*/  
import java.util.*;  
class Mycompare implements Comparator  
{  
    public int compare(Object o1,Object o2)  
    {  
        Student s1=(Student)o1;  
        Student s2=(Student)o2;  
  
        int num=s1.getName().compareTo(s2.getName());  
  
        if(num==0)  
            //return s1.getAge()-s2.getAge();  
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
          
        return num;  
    }  
}  
class Student implements Comparable//该接口强制让学生具备比较性  
{  
    private String name;  
    private int age;  
    public int compareTo(Object obj)//覆盖compateTo  
    {  
        if(!(obj instanceof Student))  
            throw new RuntimeException("不是学生对象");  
        Student s=(Student)obj;  
          
        System.out.println(this.name+"...compateTo...."+s.name);  
        if(this.age>s.age)  
            return 1;//返回正数  
  
        if(this.age==s.age)  
        {  
            return this.name.compareTo(s.name);//判断次要条件。调用String类compareTo  
        }  
        return -1;  
    }  
    Student(String name,int age)  
    {  
        this.name=name;  
        this.age=age;  
    }  
    public String getName()  
    {  
        return name;  
    }  
    public int getAge()  
    {  
        return age;  
    }  
}  
  
class TreeSetDemo2   
{  
    public static void main(String[] args)   
    {  
        TreeSet ts=new TreeSet(new Mycompare());  
        ts.add(new Student("lisi02",22));  
        ts.add(new Student("lisi007",19));  
        ts.add(new Student("lisi09",19));  
        ts.add(new Student("lisi01",40));  
        ts.add(new Student("lisi007",18));  
        ts.add(new Student("lisi02",12));  
  
        Iterator it=ts.iterator();  
        while(it.hasNext())  
        {  
            Student st=(Student)it.next();  
            System.out.println("姓名："+st.getName()+"\t年龄："+st.getAge());  
        }  
    }  
}  

五、集合框架(TreeSet练习)

[java] view plaincopy
/* 
练习：按照字符串长度排序。 
 
字符串本身具有比较性，但是它的比较方式不是所需要的。 
这是就需要比较器。 
 
*/  
import java.util.*;  
class StringLenthComparator implements Comparator  
{  
    public int compare(Object o1,Object o2)  
    {  
        String s1=(String)o1;  
        String s2=(String)o2;  
        /* 
        if(s1.length()>s2.length()) 
            return 1; 
        if(s1.length()==s2.length()) 
            return 0; 
        */  
  
        //主要条件  
        int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));  
          
  
        //次要条件  
        if(num==0)  
            return s1.compareTo(s2);  
  
        return num;  
    }  
}  
class TreeSetTest   
{  
    public static void main(String[] args)   
    {  
        TreeSet ts=new TreeSet(new StringLenthComparator());  
        ts.add("abcd");  
        ts.add("cc");  
        ts.add("cba");  
        ts.add("aaa");  
        ts.add("z");  
        ts.add("hahaha");  
  
        Iterator it=ts.iterator();  
        while(it.hasNext())  
        {  
            System.out.println(it.next());  
        }  
  
    }  
}  

六、集合框架(泛型概述)

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题。

泛型的格式：通过<>来定义要操作的引用数据类型。

在使用Java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，只要见到<>就要定义泛型。

其实<>就是用来接受类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

好处：

1.将运行时期出现的问题ClassCactException转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全。
2.避免了强制转换的麻烦。

[java] view plaincopy
/* 
泛型： 
*/  
  
import java.util.*;  
class GenericDemo   
{  
    public static void main(String[] args)   
    {  
        ArrayList<String> a1=new ArrayList<String>();  
  
        a1.add("abc01");  
        a1.add("abc099");  
        a1.add("abc0134");  
        /* 
        a1.add(4);//a1.add(new Integer(4)); 
 
        //出现异常。java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String 
         
        */  
        Iterator<String> it=a1.iterator();  
        while(it.hasNext())  
        {  
            String s=it.next();  
  
            System.out.println(s+":"+s.length());  
        }  
  
    }  
}  

七、集合框架(泛型使用)

[java] view plaincopy
/* 
泛型使用: 
*/  
import java.util.*;  
class LenComperator implements Comparator<String>  
{  
    public int compare(String o1,String o2)  
    {  
        int num=new Integer(o1.length()).compareTo(new Integer(o2.length()));  
  
        if(num==0)  
            return o1.compareTo(o2);  
  
        return num;  
    }  
}  
class GenericDemo2   
{  
    public static void main(String[] args)   
    {  
        TreeSet<String> ts=new TreeSet<String>(new LenComperator());  
        ts.add("asd");  
        ts.add("gfh");  
        ts.add("ghkl");  
        ts.add("vb");  
        ts.add("wegt");  
  
        Iterator<String> it=ts.iterator();  
  
        while(it.hasNext())  
        {  
            String s=it.next();  
            System.out.println(s);  
        }  
  
    }  
}  

八、集合框架(泛型类)

[java] view plaincopy
/* 
什么时候定义泛型类？ 
当类中的要操作的引用数据类型不确定时，早期定义Object来完成扩展。 
现在定义泛型类来完成扩展。 
*/  
class Worker  
{  
}  
class Student  
{  
}  
  
class Tool//没有泛型前的做法  
{  
    private Object obj;  
    public void setObject(Object obj)  
    {  
        this.obj=obj;  
    }  
    public Object getObject()  
    {  
        return obj;  
    }  
}  
class Utils<QQ>//泛型类  
{  
    private QQ q;  
    public void setObject(QQ q)  
    {  
        this.q=q;  
    }  
    public QQ getObject()  
    {  
        return q;  
    }  
}  
/* 
class Tool 
{ 
    private Worker w; 
    public void setWorker(Worker w) 
    { 
        this.w=w; 
    } 
    public Work getWorker() 
    { 
        return w; 
    } 
} 
*/  
class GenericDemo3   
{  
    public static void main(String[] args)   
    {  
        Utils<Worker> u=new Utils<Worker>();  
  
        u.setObject(new Worker());  
        Worker w=u.getObject();  
  
        /* 
        Tool t=new Tool(); 
        t.setObject(new Worker()); 
        Worker w=(Worker)t.getObject(); 
        */  
    }  
}  

九、集合框架(泛型方法)

[java] view plaincopy
/* 
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象 
明确要操作的具体类型后，所有方法要操作的类型就已经固定了。 
 
为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定 
义在方法上。 
 
*/  
  
/* 
class Demo<T> 
{ 
    public void show(T t) 
    { 
        System.out.println("show:"+t); 
    } 
    public void print(T t) 
    { 
        System.out.println("print:"+t); 
    } 
 
} 
*/  
class Demo  
{  
    public <T> void show(T t)  
    {  
        System.out.println("show:"+t);  
    }  
    public <Q> void print(Q q)  
    {  
        System.out.println("print:"+q);  
    }  
  
}  
class GenericDemo4   
{  
    public static void main(String[] args)   
    {  
        Demo d=new Demo();  
  
        d.show("haha");  
        d.show(new Integer(4));  
        d.print("hehe");  
    }  
}  

十、集合框架(静态方法泛型)

[java] view plaincopy
/* 
特殊之处： 
静态方法不可以访问类上定义的泛型。 
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。 
 
*/  
  
class Demo<T>  
{  
    public void show(T t)  
    {  
        System.out.println("show:"+t);  
    }  
    public <Q> void print(Q q)  
    {  
        System.out.println("print:"+q);  
    }  
    public static <W> void method(W t)  
    {  
        System.out.println("method:"+t);  
    }  
  
}  
class GenericDemo4   
{  
    public static void main(String[] args)   
    {  
        Demo<String> d=new Demo<String>();  
  
        d.show("haha");  
        //d.show(new Integer(4));  
        d.print(1234);  
        Demo.method("123456");  
    }  
}  

十一、集合框架(泛型接口)

[java] view plaincopy
/* 
泛型定义在接口上： 
*/  
interface Inter<T>  
{  
    void show(T t);  
}  
/* 
class InterImpl implements Inter<String> 
{ 
    public void show(String t) 
    { 
        System.out.println("show:"+t); 
    } 
} 
*/  
class InterImpl<T> implements Inter<T>  
{  
    public void show(T t)  
    {  
        System.out.println("show:"+t);  
    }  
}  
class GenericDemo5   
{  
    public static void main(String[] args)   
    {  
        InterImpl<Integer> i=new InterImpl<Integer>();  
        i.show(15);  
  
        /* 
        InterImpl i=new InterImpl(); 
        i.show("hehe"); 
        */  
    }  
}  

十二、集合框架(泛型限定)

[java] view plaincopy
/* 
 
?   通配符。也可以理解为占位符。 
 
泛型的限定： 
？ extends E: 可以接受E类型或E的子类型。上限。 
？ super E:可以接受E类型或E的父类型。 下限。 
 
 
*/  
import java.util.*;  
class Person  
{  
    private String name;  
    Person(String name)  
    {  
        this.name=name;  
    }  
    public String getName()  
    {  
        return name;  
    }  
}  
class Student extends Person  
{  
    Student(String name)  
    {  
        super(name);  
    }  
  
}  
class GenericDemo6   
{  
    public static void main(String[] args)   
    {  
          
        ArrayList<Person> a1=new ArrayList<Person>();  
        a1.add(new Person("abc1"));  
        a1.add(new Person("abc2"));  
        a1.add(new Person("abc3"));  
        printColl(a1);  
  
        ArrayList<Student> a2=new ArrayList<Student>();  
        a2.add(new Student("abc4"));  
        a2.add(new Student("abc5"));  
        a2.add(new Student("abc6"));  
        printColl(a2);//ArrayList<Person> a1=new ArrayList<student>(); error  
  
        /* 
        ArrayList<String> a1=new ArrayList<String>(); 
 
        a1.add("abc1"); 
        a1.add("abc2"); 
        a1.add("abc3"); 
 
        ArrayList<Integer> a2=new ArrayList<Integer>(); 
 
        a2.add(4); 
        a2.add(5); 
        a2.add(6); 
         
        printColl(a1); 
        printColl(a2); 
        */  
    }  
    public static void printColl(ArrayList<? extends Person> a1)//   下限:<? super Student>   
    {  
        Iterator<? extends Person> it=a1.iterator();  
        while(it.hasNext())  
        {  
            System.out.println(it.next().getName());  
        }  
    }  
  
    /* 
    public static void printColl(ArrayList<?> a1) 
    { 
        Iterator<?> it=a1.iterator(); 
        while(it.hasNext()) 
        { 
            System.out.println(it.next()); 
        } 
    } 
 
    */  
  
    /* 
    public static <T> void printColl(ArrayList<T> a1) 
    { 
        Iterator<T> it=a1.iterator(); 
        while(it.hasNext()) 
        { 
            System.out.println(it.next()); 
        } 
    } 
    */  
}  

十三、集合框架(泛型限定2)

[java] view plaincopy
/* 
集合框架(泛型限定2): 
*/  
import java.util.*;  
class Person  
{  
    private String name;  
  
    Person(String name)  
    {  
        this.name=name;  
    }  
    public String getName()  
    {  
        return name;  
    }  
    public String toString()  
    {  
        return "person:"+name;  
    }  
}  
class Student extends Person  
{  
    Student(String name)  
    {  
        super(name);  
    }  
  
}  
class Worker extends Person  
{  
    Worker(String name)  
    {  
        super(name);  
    }  
}  
class Comp implements Comparator<Person>  
{  
    public int compare(Person s1,Person s2)  
    {  
        return s1.getName().compareTo(s2.getName());  
    }  
}  
  
/* 
class StuComp implements Comparator<Student> 
{ 
    public int compare(Student s1,Student s2) 
    { 
        return s1.getName().compareTo(s2.getName()); 
    } 
} 
class WorkerComp implements Comparator<Worker> 
{ 
    public int compare(Worker s1,Worker s2) 
    { 
        return s1.getName().compareTo(s2.getName()); 
    } 
} 
 
*/  
class GenericDemo7  
{  
    public static void main(String[] args)   
    {  
          
        TreeSet<Student> ts=new TreeSet<Student>(new Comp());  
          
        ts.add(new Student("abc03"));  
        ts.add(new Student("abc02"));  
        ts.add(new Student("abc09"));  
        ts.add(new Student("abc07"));  
  
        Iterator<Student> it=ts.iterator();  
          
        while(it.hasNext())  
        {  
            System.out.println(it.next().getName());  
        }  
  
          
  
  
        TreeSet<Worker> ts1=new TreeSet<Worker>(new Comp());  
          
        ts1.add(new Worker("abc..19"));  
        ts1.add(new Worker("abc..17"));  
        ts1.add(new Worker("abc..13"));  
        ts1.add(new Worker("abc..15"));  
          
        Iterator<Worker> it1=ts1.iterator();  
          
        while(it1.hasNext())  
        {  
            System.out.println(it1.next().getName());  
        }  
    }  
}  

0 0