java基础整理十五（集合二）

TreeSet:可以对Set集合中的元素进行排序

import java.util.*;
class  TreeSetDemo
{
public static void main(String[] args) 
{
TreeSet ts = new TreeSet();
ts.add("lisi02",23);
ts.add("lisi012",24);
ts.add("lisi003",45);
ts.add("lisi03",25);
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"---"+stu.getAge());//abc/bba/cab/cba自然顺序进行排序
}
}
}


TreeSet存储自定义对象练习:向TreeSet集合中存储自定义对象学生.想按照学生的年龄进行排序.
记住:排序时,当主要条件相同时一定要判断一下次要条件.
承接上方代码:
class Student implements Comparable//该接口强制让学生具备比较性
{
private String namei;
private int age;


student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
if(this.age>s.age)
return 1;
if(this.age=s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}


TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的这时就需要让集合自身具备比较性
在集合初始化时就有了比较方式
当两者种排序都存在时,以比较器为主,建立比较器方法:定义一个类实现Comparator接口,覆盖compare方法.
定义比较器，将比较器作为对象传递给TreeSet构造函数
import java.util.*;
class  TreeSetDemo
{
public static void main(String[] args) 
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add("lisi02",23);
ts.add("lisi012",24);
ts.add("lisi003",45);
ts.add("lisi03",25);
Iterator it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"---"+stu.getAge());//abc/bba/cab/cba自然顺序进行排序
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
private String namei;
private int age;


student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"--compareto--"+s.name);
if(this.age>s.age)
return 1;
if(this.age=s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
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)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
/*if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()==s2.getAge())
return 0;
return -1;*/相对复杂
}
return num;
}
}


练习：按照字符串长度排序
import java.util.*;
class TreeSetTest
{
public static void main(String[]args)
{
TreeSet ts = new TreeSet(new MyCompare());
ts.add("abcd");
ts.add("cc");
ts.add("cb");
ts.add("cba");
ts.add("z");
ts.add("haha");
Iterator it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
class MyCompare implements Comparator//自定义比较器
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
{
return s1.compareTo(s2);
}
return num;
}
}


泛型:JDK1.5版本之后出现的新特性,用于解决安全问题,是一个安全机制
好处:1,将运行时期出现问题ClassCastException,转移到了编译时期,方便程序员解决问题.
2,避免了强制转换麻烦


泛型的格式:通过<>来定义要操作的引用数据类型,在使用将ava提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,只要见到<>就要定义泛型.<>用于接收类型.使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可


import java.util.*;
class GenerDemo
{
public static void main(String[]args)
{
ArrayList<String> al = new ArrayList<String>();//规定集合中存储数据类型
al.add("abc01");
al.add("abc021");
al.add("abc009");


Iterator<String> it =al.terator();
while (it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
实例2：
import java.util.*;
class GenerDemo
{
public static void main(String[]args)
{
ArrayList<String> al = new ArrayList<String>();//规定集合中存储数据类型
al.add("abc01");
al.add("abc021");
al.add("abc009");


Iterator<String> it =al.terator();//迭代器泛型
while (it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
class MyCompare implements Comparator<String>//此处避免下面强转
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num==0)
return s1.compareTo(s2);
return num;
}
}


泛型类:
什么时候定义泛型类?当类中要操作的引用数据类型不确定的时候,早期定义Object来完成扩展
现在定义泛型类来完成扩展.
import java.util.*;
class Worker
{
}
class Student
{
}
class Utils<QQ>//泛型类
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
class GenerDemo
{
public static void main(String[]args)
{
Utils<Worker> u = new Utils<Worker>();
Worker w = u.getObject();
System.out.println(w);
}
}


泛型方法:
泛型类定义的泛型在整个类中有效,如果被方法使用,泛型类的对象明确要操作的具体类型后,所要操作的类型已经固定
为了让不同方法可以操作不同类型,而且类型还不确定可以讲泛型定义在方法上.
特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上
public static <w> void method(W t)泛型放在返回值类型之前


class Demo
{
public<T>void show(T t)
{
System.out.printl("show"+t);
}
public<Q>void print(Q q)
{
System.out.println("print:"+q);
}
}
class GerDemo
{
public static void main(String[]args)
{
Demo d = new Demo();
d.show("haha");
d.show(new Integer(2));
d.print("pipi");
}
}


泛型定义在接口上:
interface Inter<T>
{
void show(T t);
}
/*
class InterImp 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 GenDemo
{
public static void main(String[]args)
{
InterImpl<Integer>i = new InterImpl<Integer>();
i.show(4);
/*InterImp i = new InterImpl();
i.show("haha");*/
}
}


<?>  通配符。可理解为占位符 即类型不确定的时候可以其都能应用
<? extends E>可以接收E类型或E类型的子类型。 上限
<? super E>可以接收E类型或者E的付类型。 下限