黑马程序员--- 学习笔记(第十五天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
Set:无序,不可以重复
|--HashSet:底层是哈希表数据结构,线程是不同步的,保证元素
唯一性的原理是:判断元素的hashCode值是否相同,如果相同还会继续判断
元素的equals方法,是否为true
|--TreeSet:可以对Set集合中的元素进行排序,底层是二叉树数据结构
,保证元素唯一性的依据是:compareTo方法return 0

/*
TreeSet
一种方式实现排序按照年龄排序
第一种:实现comparable接口复写compareTo方法,让元素自身具备比较性

一种方式实现按字符串长度排序
第二种:实现comparator接口,复写compare方法,让集合具备比较性
*/
import java.util.*;
class Demo1 
{
	public static void main(String[] args) 
	{
		TreeSet<Student> t=new TreeSet<Student>(new ComparatorImpl());
		t.add(new Student("ab",11));
		t.add(new Student("b",2));
		t.add(new Student("bdc",2));
		t.add(new Student("bdc",2));
		t.add(new Student("cffffffff",3)); 
		t.add(new Student("cdd",3)); 
		t.add(new Student("daaaaa",14));
		t.add(new Student("ddrrr",14));

		Iterator<Student> it=t.iterator();
		for (;it.hasNext() ; )
		{
			Student s=it.next();
			System.out.println(s.getName()+"--"+s.getAge());
		}
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		  this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Student(String name, int age){
		this.name=name;
		this.age=age;
	}
	public int compareTo(Student stu){
		int num= new Integer(this.age).compareTo(new Integer(stu.getAge()));
		if(num==0){
			return this.name.compareTo(stu.getName());
		}


		return num;
		
	}
}
class ComparatorImpl implements Comparator<Student>
{
	public int compare(Student s1,Student s2){
		int num=new Integer(s2.getName().length()).compareTo(new Integer(s1.getName().length()));
		if(num==0){
			return new Integer(s2.getAge()).compareTo(new Integer(s1.getAge()));
		}	
		return num;
	}
}

记住:排序时,主要条件相同时,就判断次要条件


TreeSet排序的第一种方式:
让元素自身具备比较性,元素实现comparable接口,复写compareTo方法
,也称为元素的自然顺序或默认顺序
TreeSet排序的第二种方式:
当元素自身不具备比较性,或者具备的比较性不是所需的,这时就需要让
集合自身具备比较性,就需要用到了比较器comparator




定义比较器,将它传递给TreeSet的构造函数
当两种比较方式都存在,以比较器为主,

/*
按照字符长度排序
*/
import java.util.*;
class Demo2 
{
	public static void main(String[] args) 
	{
		TreeSet<String> t=new TreeSet<String>(new LengthCompare());
		t.add("aa");
		t.add("ccddd");
		t.add("ddd");
		t.add("ddd");

		Iterator<String> it=t.iterator();
		for (;it.hasNext() ; )
		{
			System.out.println(it.next());
		}
	}		   
}
/*长度比较器*/
class LengthCompare 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;
	}
}			

泛型:
JDK1.5出现以后出现的新特性,用于解决安全问题,是一个类型安全机制


好处:
1.将运行时期出现问题ClassCastException转移到了编译时期,方便于
程序员解决问题,让运行事情问题减少,安全
2.避免了强制转换的麻烦


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


 在使用java提供的对象时, 什么时候定义泛型呢?
 通常在集合框架中很常见,只要见到<>就是要定义泛型
 其实<>就是用来接收类型的 


 当使用集合时,将集合要存储的数据类型做参数传递到<>即可


 什么时候定义泛型类?
 当类中要操作的引用数据类型不确定的时候,早期定义Object
 来完成扩展,现在定义泛型来完成扩展

/*
泛型类和泛型方法


*/
class Demo3 
{
	public static void main(String[] args) 
	{
		GenericDemo<String> g=new GenericDemo<String>();
		g.show(new String("字符串对象"));
		//g.show(new Integer(5));	//无法使用Integer
		g.print(new Double(5.22));//这就可以了.方法泛型
		GenericDemo.staticMethod(new Character('d'));
	}
}
class GenericDemo<T>
{
	private T t;
	public void set(T t){
		this.t=t;
	}
	public T get(){
		return t;
	}
	public void show(T t){
		System.out.println(t);
	}
	/*泛型类可以定义非静态泛型方法*/
	public <Q> void print(Q q){
		System.out.println(q);
	}
	
	/*
	//泛型类不可以定义使用类中泛型的静态方法
	//这是先加载后加载的问题
	public static void method(T t){
		 System.out.println(t);
	}
	*/
	/*泛型类可以定义静态泛型方法*/
	public static <E> void staticMethod(E e){
		System.out.println(e);
	}
}

 泛型类定义的泛型,在整个类都有效,如果被方法使用,那么
 泛型类的对象明确操作的具体之后,所有要操作的类型它已经固定
 ,为了让不同的方法可以操作不同的类型,而且类型还不确定,那么可以
 将泛型定义在方法上.

/*
泛型接口
*/
class Demo4 
{
	public static void main(String[] args) 
	{
		 Test<String> t=new Test<String>();
		 t.show(new String("")); 
		// t.show(new Integer("1")); 
		// t.method(new Integer(1));
		 t.method(new String("1"));
		 t.print(new Double(1.2));
		 
	}
}
interface GenericInter<T>
{
	public abstract void show(T t);
	public abstract <Q> void print(Q q);
}
class Test<T> implements GenericInter<T>
{
	//错误的
	//public void show(Integer I){}
	public void method(T t){
	
	}
	public void show(T t){}
	public <Q> void print(Q q){}
}

 特殊之处:
 静态方法不可以访问类上定义的泛型,如果静态方法操作的引用数据
 类型是不确定的,可以定义在方法上,要放在返回值前面


 泛型的限定:

 ? extends E :可以接收E类型或者E的子类. 上限限定

/*
? extends E
*/
import java.util.*;
class Demo5 
{
	public static void main(String[] args) 
	{
		ArrayList<Student> al=new ArrayList<Student>();
		al.add(new Student("dd",15));
		al.add(new Student("ddd",12));
		//只能接收collection集合中对象是Person的子类
		print(al);
	}	
	public static void print(Collection<? extends Person> c){
		 Iterator<? extends Person> it=c.iterator();
		 for ( ;it.hasNext() ; )
		 { 
			 System.out.println(it.next().getName());
		 }
	}
}
class Person
{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
	  return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
}
class Student extends Person
{
	public Student(String name,int age){
		super(name,age);
	}
}
class Worker extends Person
{
	public Worker(String name, int age){
		super(name,age);
	}
}

 ? super E:可以接收E类型或者E的父类型. 下限限定

/*
? super E
*/
import java.util.*;
class Demo6 
{
	public static void main(String[] args) 
	{
		TreeSet<Person> ts=new TreeSet<Person>(new Comp());
		 ts.add(new Person("dd",10));
		 ts.add(new Person("dddd",15));
		 ts.add(new Person("dddddd",12));

		//print(ts);
	}
	public static void print(Collection<? extends Person> c){
			 Iterator<? extends Person> it=c.iterator();
			 for (;it.hasNext() ; )
			 {
				 System.out.println(it.next().getAge());
			 }
	}
}
class Comp implements Comparator<Person>
{
	public int compare(Person s,Person s1){
		return new Integer(s.getAge()).compareTo(new Integer(s1.getAge()));	
	}
}
 class Person
{
	private String name;
	private int age;
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
	  return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
}
class Student extends Person
{
	public Student(String name,int age){
		super(name,age);
	}
}

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————