一、集合框架(TreeSet)
- /*
- 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存储自定义对象)
- /*
- 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());
- }
- }
- }
三、集合框架(二叉树)
- /*
- 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方式排序)
- /*
- 当元素自身不具有比较性,或者具备的比较性不是所需要的。这时就需要
- 让集合自身具有比较性。就是在集合初始化时就有了比较方式。
- 定义一个比较器,将比较器对象作为参数传递给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练习)
- /*
- 练习:按照字符串长度排序。
- 字符串本身具有比较性,但是它的比较方式不是所需要的。
- 这是就需要比较器。
- */
- 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.避免了强制转换的麻烦。
- /*
- 泛型:
- */
- 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());
- }
- }
- }
七、集合框架(泛型使用)
- /*
- 泛型使用:
- */
- 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);
- }
- }
- }
八、集合框架(泛型类)
- /*
- 什么时候定义泛型类?
- 当类中的要操作的引用数据类型不确定时,早期定义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();
- */
- }
- }
九、集合框架(泛型方法)
- /*
- 泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象
- 明确要操作的具体类型后,所有方法要操作的类型就已经固定了。
- 为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定
- 义在方法上。
- */
- /*
- 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");
- }
- }
十、集合框架(静态方法泛型)
- /*
- 特殊之处:
- 静态方法不可以访问类上定义的泛型。
- 如果静态方法操作的引用数据类型不确定,可以将泛型定义在方法上。
- */
- 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");
- }
- }
十一、集合框架(泛型接口)
- /*
- 泛型定义在接口上:
- */
- 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");
- */
- }
- }
十二、集合框架(泛型限定)
- /*
- ? 通配符。也可以理解为占位符。
- 泛型的限定:
- ? 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)
- /*
- 集合框架(泛型限定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());
- }
- }
- }