今天是java学习第15天，学习了集合内容的TreeSet数据和泛型。
import java.util.*;
/*
Set:无序，不可以重复元素
|--HashSet:数据结构是哈希表，线程时非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同
如果相同，还会继续判断元素的equals方法，是否为true
|--TreeSet:可以对Set集合中的元素进行排序
底层数据结构式二叉树
保证元素唯一性的依据：
compareTo方法return 0；
TreeSet排序的第一种方法：让元素自身具备比较性，
元素需要实现Comparable接口，覆盖compareTo方法
这种方式也称为元素的自然顺序，或者叫做默认顺序
TreeSet排序的第二种排序方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式，
需求：
往TreeSet集合汇总存储自定义对象学生，
想按照学生的年龄进行排序
记住，排序时，当主要条件相同时，一定要判断一下次要条件
*/
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
/*
public int compareTo(Object obj)//该方法的打印出来的结果是，怎么输入进去，就怎么打印出来
{
return 1;
}
*/
public int compareTo(Object obj) //判断本类对象的年龄与传入对象的年龄的大小
{
if (!(obj instanceof Student))
{
throw new RuntimeException("不是学生类");
}
Student stu = (Student)obj;
System.out.println(this.getName()+"......"+stu.getName());
if (this.age<stu.age)
return -1;
if(this.age==stu.age) //年龄相同情况下，再比较姓名是否相同
{
return this.name.compareTo(stu.name);
}
return 1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class TreeSetDemo2
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("zzh001",23));
ts.add(new Student("zzh002",24));
ts.add(new Student("zzh004",23));
ts.add(new Student("zzh003",25));
//ts.add(new Student("zzh004",26));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student s = (Student)(it.next());
sop(s.getName()+"..."+s.getAge());
}
}
}
import java.util.*;
/*
Set:无序，不可以重复元素
|--HashSet:数据结构是哈希表，线程时非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同
如果相同，还会继续判断元素的equals方法，是否为true
|--TreeSet:可以对Set集合中的元素进行排序
底层数据结构式二叉树
保证元素唯一性的依据：
compareTo方法return 0；
TreeSet排序的第一种方法：让元素自身具备比较性，
元素需要实现Comparable接口，覆盖compareTo方法
这种方式也称为元素的自然顺序，或者叫做默认顺序
当元素自身不具备比较性时，或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式，
就定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
需求：
往TreeSet集合汇总存储自定义对象学生，
想按照学生的年龄进行排序
(现在按照对象的姓名来排序，需要定义对象的比较器)
记住，排序时，当主要条件相同时，一定要判断一下次要条件
当两种排序都存在时，以比较器为主
定义一个类，实现Comparator接口，覆盖compare方法
*/
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
/*
public int compareTo(Object obj)//该方法的打印出来的结果是，怎么输入进去，就怎么打印出来
{
return 1;
}
*/
public int compareTo(Object obj) //判断本类对象的年龄与传入对象的年龄的大小
{
if (!(obj instanceof Student))
{
throw new RuntimeException("不是学生类");
}
Student stu = (Student)obj;
//System.out.println(this.getName()+"......"+stu.getName());
if (this.age<stu.age)
return -1;
if(this.age==stu.age) //年龄相同情况下，再比较姓名是否相同
{
return this.name.compareTo(stu.name);
}
return 1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class TreeSetDemo3
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("zzh001",23));
ts.add(new Student("zzh002",24));
ts.add(new Student("zzh002",29));
ts.add(new Student("zzh003",25));
//ts.add(new Student("zzh002",24));
//ts.add(new Student("zzh004",26));
Iterator it = ts.iterator();
while (it.hasNext())
{
Student s = (Student)(it.next());
sop(s.getName()+"..."+s.getAge());
}
}
}
class MyCompare implements Comparator
{
public int compare(Object obj1,Object obj2)
{
Student stu1 = (Student)obj1;
Student stu2 = (Student)obj2;
int num = stu1.getName().compareTo(stu2.getName());
if (num==0)
{
return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
/*
if (stu1.getAge()>stu2.getAge())
return 1;
if (stu1.getAge()==stu2.getAge())
return 0;
return -1;
*/
}
return num;
}
}
import java.util.*;
/*
需求：按照字符串长度排序
字符串本身具备比较性，但是它的比较方式不是所需要的，
这时就只能使用比较器
*/
class TreeSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add("asffghbc");
ts.add("aaa");
ts.add("abc");
ts.add("ou");
ts.add("p");
ts.add("sfhj");
Iterator it = ts.iterator();
while (it.hasNext())
{
sop(it.next());
}
}
}
class MyCompare implements Comparator
{
public int compare(Object obj1,Object obj2)
{
String s1 = (String)obj1;
String s2 = (String)obj2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num==0)
{
return s1.compareTo(s2);
}
return num;
/*
if (s1.length()>s2.length())
return 1;
if(s1.length()==s2.length())
return 0;
return -1;
*/
}
}
import java.util.*;
/*
泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制
好处
1，将运行时期出现问题ClassCastException（类型转换异常），转移到了编译时期
方便于程序员解决问题，让运行事情问题减少，安全。。。
2，避免了强制转换麻烦
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常用
只要见到<>就要定义泛型
其实<>就是用来接收类型的
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
class GenericDemo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("abc");
al.add("abc1564");
al.add("abc054");
al.add("abc22");
Iterator it = al.iterator();
while (it.hasNext())
{
String s = (String)(it.next());
System.out.println(s+"..."+s.length());
}
}
}
*/
//使用泛型
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("abc1564");
al.add("abc054");
al.add("abc22");
Iterator<String> it = al.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s+"..."+s.length());
}
}
}
import java.util.*;
/*
泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制
好处
1，将运行时期出现问题ClassCastException（类型转换异常），转移到了编译时期
方便于程序员解决问题，让运行事情问题减少，安全。。。
2，避免了强制转换麻烦
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常用
只要见到<>就要定义泛型
其实<>就是用来接收类型的
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
*/
class GenericDemo2
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new LenStrComparator());
ts.add("abc");
ts.add("cc");
ts.add("cba");
ts.add("z");
ts.add("aaa");
ts.add("hahahha");
Iterator<String> it = ts.iterator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s+"..."+s.length());
}
}
}
//泛型在比较器中的引用，按照字符串长度打印出来，
//步骤：1，定义类实现Comprarator接口
class LenStrComparator implements Comparator<String>
{
public int compare(String obj1,String obj2)
{
//compareto() 方法用于比较
int num = new Integer(obj1.length()).compareTo(new Integer(obj2.length()));
if (num==0)
{
return obj1.compareTo(obj2); //compareto()按照自然排序方法排序
}
return num;
}
}
//import java.util.*;
/*
*/
class Student
{
}
class Worker
{
}
//泛型前做法，使用的类型判断工具
/*
class Tool
{
private Object obj ;
public void setObject(Object obj)
{
this.obj=obj;
}
public Object getObject()
{
return obj;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Tool t = new Tool();
t.setObject(new Student());
Worker work =(Worker)t.getObject();
}
}
*/
//泛型类
//泛型类定义的泛型，在整个类中有效，如果被方法使用
//那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了
class Utils<Spider>
{
private Spider sp;
public void setObject(Spider sp)
{
this.sp=sp;
}
public Spider getObject()
{
return sp;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
//
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());
Worker work =u.getObject();
}
}
/*
泛型类定义的泛型，在整个类中有效，如果被方法使用
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了
解决办法：
泛型定义在方法上
为了让不同方法可以操作不同类型，而且类型还不确定
那么可以将泛型定义在方法上
特殊之处：
静态方法不可以访问类上定义的泛型
如果静态方法操作的引用数据类型不确定，可以定义在方法上
*/
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 w)
{
System.out.println("method..."+w);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo<String> d = new Demo<String>();
d.show("spider");
d.print(new Integer(5));
Demo.method("jalgja");
}
}
/*
泛型定义在接口上
*/
interface Inter<T>
{
void show(T t);
}
/*
class InterImpl implements Inter<String>
{
public void show(String s)
{
System.out.println("inter...show..."+s);
}
}
class GenericDemo5
{
public static void main(String[] args)
{
InterImpl i = new InterImpl();
i.show("spider");
}
}
*/
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("inter...show..."+t);
}
}
class GenericDemo5
{
public static void main(String[] args)
{
InterImpl<Integer> i = new InterImpl<Integer>();
//i.show("spider");
i.show(5);
}
}
import java.util.*;
/*
? 通配符，也可以理解为占位符
泛型的限定
？ extends E ：可以接收E类型或者E的子类型，上限
？ super E ：可以接收E类型或者E的父类型，下限
*/
/*
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc01");
al.add("abc02");
al.add("adc03");
al.add("aaa05");
ArrayList<Integer> al1 = new ArrayList<Integer>();
al1.add(3);
al1.add(8);
al1.add(5);
printAl(al1); //
}
public static void printAl(ArrayList<?> al)//?通配符，可以打印集合的不限定泛型
{
Iterator<?> it = al.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
*/
//当打印对象的类型变为子父类时的处理
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc01");
al.add("abc02");
al.add("adc03");
al.add("aaa05");
ArrayList<Student> al1 = new ArrayList<Student>();
al1.add(new Student("abc...01"));
al1.add(new Student("abc...02"));
al1.add(new Student("abc...06"));
printAl(al1);
}
//使用泛型限定，? extends Person上限，接收Person类及其子类
public static void printAl(ArrayList<? extends Person> al) //ArrayList<Person> al = new ArrayList<Student>();这样会出错，将猪放到动物的圈中
{
Iterator<? extends Person> it = al.iterator();
while (it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
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);
}
}
import java.util.*;
/*
*/
class GenericDemo7
{
public static void main(String[] args)
{
TreeSet<Student> al = new TreeSet<Student>(new PersonComp());
al.add(new Student("student01"));
al.add(new Student("student08"));
al.add(new Student("student05"));
al.add(new Student("student02"));
Iterator<Student> it = al.iterator(); //定义迭代器
while (it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Worker> al1 = new TreeSet<Worker>(new PersonComp());
al1.add(new Worker("Worker09"));
al1.add(new Worker("Worker05"));
al1.add(new Worker("Worker06"));
al1.add(new Worker("Worker02"));
Iterator<Worker> it1 = al1.iterator(); //定义迭代器
while (it1.hasNext())
{
System.out.println(it1.next().getName());
}
}
}
/*
class StuComp implements Comparator<Student> //学生姓名比较器
{
public int compare(Student stu1,Student stu2)
{
return stu1.getName().compareTo(stu2.getName());
}
}
class WorkerComp implements Comparator<Worker> //学生姓名比较器
{
public int compare(Worker w1,Worker w2)
{
return w1.getName().compareTo(w2.getName());
}
}
*/
//上面代码改用父类比较器
class PersonComp implements Comparator<Person> //学生姓名比较器
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}
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 Worker extends Person
{
Worker(String name)
{
super(name);
}
}
445
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
