Java基础--集合框架(HashSet、TreeSet、泛型)
2015-12-19 19:09
656 查看
Set集合体系
Set集合中元素是无序的(存入和取出的顺序不一定一致),元素不可以重复;Set接口常用类
HashSet:底层数据结构是哈希表,线程是非同步的;TreeSet:底层数据结构 是二叉树,可以对Set集合中的元素进行排序,线程非同步;
Set集合取出方式:Set集合的功能和Collection是一致的,取出方式只有一种Iterator;
HashSet
HashSet保证元素唯一性的方式HashSet通过元素的两个方法:hashCode()和equals来完成,如果元素的hashCode值相同,才会判断equals是否为true,如果元素的hashCode值不同,不会调用equals;
存入到HashSet集合中的自定义对象,一般要复写hashCode和equals方法,这两个方法是集合底层自动调用的;
注:对于判断元素是否存才,以及删除等操作,HashSet依赖的方法是元素的hashCode和equals方法,ArrayList依赖的是equals;
示例代码:
class HashSetTest { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { HashSet hs = new HashSet(); hs.add(new Person("a1",11)); hs.add(new Person("a2",12)); hs.add(new Person("a3",13)); // hs.add(new Person("a2",12)); // hs.add(new Person("a4",14)); //sop("a1:"+hs.contains(new Person("a2",12))); // hs.remove(new Person("a4",13)); Iterator it = hs.iterator(); while(it.hasNext()) { Person p = (Person)it.next(); sop(p.getName()+"::"+p.getAge()); } } } class Person { private String name; private int age; Person(String name,int age) { this.name = name; this.age = age; } public int hashCode() { System.out.println(this.name+"....hashCode"); return name.hashCode()+age*37; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; System.out.println(this.name+"...equals.."+p.name); return this.name.equals(p.name) && this.age == p.age; } public String getName() { return name; } public int getAge() { return age; } }
TreeSet
TreeSet可以对set集合中的元素排序,底层数据结构是二叉树;TreeSet保证元素唯一性的方式有两种:
第一种方式:需存入的元素自身具有比较性,元素可通过实现Comparable接口,复写compareTo(T o)方法;该方法中如果对象小于,等于或大于指定对象则分别返回负整数,零正整数,这种方式称为元素的自然顺序;
Comparable< T>接口,用于对象内部比较方法,该接口下的实现方法格式为:
int compareTo(T o);该方法需要传入一个参数,参数类型必须与接口上的类型保持一致;
附:String类中已经实现该接口并复写了该方法,故当传入的对象是String类时,元素将自动按字典顺序排序;
第二种方式:自定义比较器;当元素自身不具备比较性时,或者具备的比较性不是所需的,这时就需要让集合自身具备比较性,在集合初始化时,就有了比较方式;可以自定义比较器,将比较器对象作为参数传递给TreeSet集合的构造函数;
自定义比较器要实现Comparator接口,复写compare()方法;
Comparator< T>接口,该接口下的compare方法格式为:
int compare(T o1,T o2);该方法需要传入两个参数,参数类型与接口上的类型一致;
没有比较器传入时自动调用元素自身的比较方式,当两种方式都存在时,以比较器为主;
注:定义比较方法时,当主要条件相同时,一定要判断次要元素;
所有的自定义元素(对象)在复写比较方法时可以先通过instanceOf判断是否是同类元素;
示例代码
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 0; 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 TreeSetDemo2 { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi02",21)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi06",18)); ts.add(new Student("lisi06",18)); ts.add(new Student("lisi007",29)); //ts.add(new Student("lisi007",20)); //ts.add(new Student("lisi01",40)); Iterator it = ts.iterator(); while(it.hasNext()){ Student stu = (Student)it.next(); System.out.println(stu.getName()+"..."+stu.getAge()); } } } 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 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; } }
泛型
概述
JDK1.5版本以后出现的新特性,用于解决安全问题;泛型的好处
将运行时期出现问题classcastException转移到了编译时期,方便于程序员解决问题;避免了强制转换的麻烦;
注:泛型内定义的都是引用数据类型;
泛型的定义
泛型定义的格式通过<>来定义要操作的引用数据类型;
例:
ArrayList<String> al=new ArrayList<String>(); Iterator<String> it=al.iterator();
在使用Java提供的对象是,什么时候写泛型呢?
通常在集合框架中很常见,只要见到<>就要定义泛型,其实<>就是用来接收类型的,当使用集合时,将集合中要存储的数据类型作为参数传递到<>即可;
import java.util.*; class GenericDemo2 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new LenComparator()); ts.add("abcd"); ts.add("cc"); ts.add("cba"); ts.add("aaa"); ts.add("z"); ts.add("hahaha"); Iterator<String> it = ts.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s); } } } class LenComparator implements Comparator<String>{ public int compare(String o1,String o2){ int num = new Integer(o2.length()).compareTo(new Integer(o1.length())); if(num==0) return o2.compareTo(o1); return num; } }
泛型类
但类中要操作的引用数据类型不确定的时候,早起定义Object来完成扩展,现在定义泛型来完成扩展,例:class Util<QQ> { private QQ q; public void setObject(QQ q) { this.q=q; } public QQ getObject() { return q; } }
泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了;
为了让不同方法可以操作不同类型,而且类型还不确定,那么可以将泛型定义在方法上,例:
class Demo<T> { public void show(T t) { System.out.println("show:"+t); } public <Q> void print() { System.out.println("print:"+q); } }
注:以上示例类和方法中都定义了泛型,不矛盾,类中的泛型整个类中都可以使用,方法上定义的泛型仅在本方法中有效,方法可不使用类中的泛型而有自己的泛型;
特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上;
示例代码:
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(4); d.print(5); d.print("hehe"); Demo.method("hahahahha"); /* Demo d = new Demo(); d.show("haha"); d.show(new Integer(4)); d.print("heihei"); Demo<Integer> d = new Demo<Integer>(); d.show(new Integer(4)); d.print("hah"); Demo<String> d1 = new Demo<String>(); d1.print("haha"); d1.show(5); */ } }
泛型定义在接口上
例:interface Inter<T>{ void show(T 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(4); //InterImpl i = new InterImpl(); //i.show("haha"); } }
泛型限定
< ? >:通配符,也可以理解为占位符;< ? extends E>:可以接收E 类型或者E的子类型,上限;
< ? super E>:可以接收E 类型或者E的父类型,下限;
class a415 GenericDemo6{ public static void main(String[] args) { ArrayList<Person> al = new ArrayList<Person>(); al.add(new Person("abc1")); al.add(new Person("abc2")); al.add(new Person("abc3")); ArrayList<Student> al1 = new ArrayList<Student>(); al1.add(new Student("abc--1")); al1.add(new Student("abc--2")); al1.add(new Student("abc--3")); printColl(al1); //ArrayList<? extends Person> al = new ArrayList<Student>();error } public static void printColl(Collection<? extends Person> al){ 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); } } class Comp implements Comparator<Person>{ public int compare(Person s1,Person s2){ return s1.getName().compareTo(s2.getName()); } }
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- c++11 + SDL2 + ffmpeg +OpenAL + java = Android播放器
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树