Java基础_集合框架2

于 2012-08-14 20:50:45 发布
阅读量445 收藏
点赞数
分类专栏： Java基础特性 文章标签： java string class integer iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yangcheng91/article/details/7866615
版权

一、集合框架(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());
		}
	}
}


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值