黑马程序员12.集合框架2&泛型
2014-07-11 09:59
211 查看
-------android培训、java培训、java学习型技术博客、期待与您交流!
----------
今天学习了毕老师java基础第15天的内容,在这里总结一下。
|--HashSet:数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理:判断元素的hashCode值是否相同。
如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第一种方式:让元素自身具备比较性。
元素需要实现Comparable接口,覆盖compareTo方法。
这种方式也称为元素的自然顺序,或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
排序了。字母的自然顺序。
TreeSet:可以对Set集合中的元素进行排序。
更改代码:
ts.add(new Student("lisi02",22));
//ts.add(new Student("lisi007",20));
//ts.add(new Student("lisi09",19));
//ts.add(new Student("lisi01",40));
TreeSet必须排序,但是Student不具备比较性,所以报错。
add的时候自动调用了compareTo()。
年龄相同会加不进去,所以得比较一下姓名(字符串)。字符串是具备比较行为的。Stirng实现了comparable接口。
修改代码:
保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第一种方式:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也称为元素的自然顺序,或者叫做默认顺序。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时,就有了比较方式。
当元素自身不具备比较性,或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器实现方法:
定义一个类,实现Comparator接口,覆盖compare方法。
二叉树都是用return0来判断元素是否相同。
编译没问题,运行有问题,这样是不行的,得把问题在编译的时候就暴露出来。
这个问题是因为传进去的类型不一致。
泛型:JDK1.5版本以后出现新特性。用于解决安全问题,是一个类型安全机制。
好处
1.将运行时期出现问题ClassCastException,转移到了编译时期。,
方便于程序员解决问题。让运行时问题减少,安全。,
2,避免了强制转换麻烦。
ArrayList<String> al = new ArrayList<String>(); 定义了ArrayList容器,容器里面的元素是String类型的
避免强转:
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,
只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
泛型类定义的泛型,在整个类中有效。如果被方法使用,
那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。
那么可以将泛型定义在方法上。
静态方法不可以访问类上定义的泛型。
如果静态方法操作的引 用数据类型不确定,可以将泛型定义在方法上。
类的类型的明确要等到对象的建立:
class Demo<T>中的T要等到Demo<String> d = new Demo<String>()时才会变成String,但是static声明的泛型在class存在的时候就已经存在在内存中的方法区中了。它存在的时候还没有对象。
泛型的定义放在返回值得前面,修饰符的后面。
泛型限定super
-------android培训、java培训、java学习型技术博客、期待与您交流!
----------
----------
今天学习了毕老师java基础第15天的内容,在这里总结一下。
集合框架
TreeSet
Set:无序,不可以重复元素。|--HashSet:数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理:判断元素的hashCode值是否相同。
如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第一种方式:让元素自身具备比较性。
元素需要实现Comparable接口,覆盖compareTo方法。
这种方式也称为元素的自然顺序,或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
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集合中的元素进行排序。
TreeSet存储自定义对象
import java.util.*; /* 需求: 往TreeSet集合中存储自定义对象学生。 想按照学生的年龄进行排序。 */ class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi01",40)); Iterator it = ts.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } } class Student { private String name; private int age; Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } }
更改代码:
ts.add(new Student("lisi02",22));
//ts.add(new Student("lisi007",20));
//ts.add(new Student("lisi09",19));
//ts.add(new Student("lisi01",40));
TreeSet必须排序,但是Student不具备比较性,所以报错。
import java.util.*; /* 需求: 往TreeSet集合中存储自定义对象学生。 想按照学生的年龄进行排序。 */ class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); 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 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) { 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 0; } return -1; } public String getName() { return name; } public int getAge() { return age; } }
add的时候自动调用了compareTo()。
年龄相同会加不进去,所以得比较一下姓名(字符串)。字符串是具备比较行为的。Stirng实现了comparable接口。
修改代码:
if (this.age==s.age) { return this.name.compareTo(s.name); }记住,排序时,当主要条件相同时,一定判断一下次要条件。
二叉树
底层数据结构是二叉树。保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第一种方式:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也称为元素的自然顺序,或者叫做默认顺序。
实现Comparator方法排序
TreeSet的第二种排序方式。当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时,就有了比较方式。
当元素自身不具备比较性,或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
import java.util.*;
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",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",18));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
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)
{
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 02)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
return s1.getName().compareTo(s2.getName());
}
}
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;当两种排序都存在时,以比较器为主。
比较器实现方法:
定义一个类,实现Comparator接口,覆盖compare方法。
二叉树都是用return0来判断元素是否相同。
TreeSet练习
/* 练习:按照字符串长度排序。 字符串本身具备比较性。但是它的比较方式不是所需要的。 这时就只能使用比较器。 */ import java.util.*; class TreeSetTest { public static void main(String[] args) { TreeSet ts = new TreeSet(new StrLenComparator()); 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()); } } } class StrLenComparator 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; } }练习2
/* "90 -7 0 18 2 45 4" 将字符串中的数值进行排序。使用TreeSet完成。 思路 1,将字符串切割。 2,可以将这些对象存入TreeSet集合。因为TreeSet自身具备排序功能。 */ import java.util.*; class TreeSetTest2 { public static void main(String[] args) { ArrayList al = new ArrayList(); String str = "90 -7 0 18 2 45 4"; String[] arr = str.split(" "); TreeSet ts = new TreeSet(); for(int x=0; x<arr.length; x++) { //ts.add(new Integer(arr[x])); ts.add(Integer.parseInt(arr[x]));// } System.out.println(ts); } }
泛型
泛型概述
import java.util.*; class GenericDemo { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("abc01"); al.add("abc0991"); al.add("abc014"); al.add(new Integer(4));//al.add(4)是不行的,集合只能添加对象,不能添加基本数据类型。但是1.5版本后,java提供了自动装箱,所以还是可以的。 Iterator it = al.iterator(); while (it.hasNext()) { String s = (String)it.next(); System.out.println(s+":"+s.length()); } } }
编译没问题,运行有问题,这样是不行的,得把问题在编译的时候就暴露出来。
这个问题是因为传进去的类型不一致。
泛型:JDK1.5版本以后出现新特性。用于解决安全问题,是一个类型安全机制。
好处
1.将运行时期出现问题ClassCastException,转移到了编译时期。,
方便于程序员解决问题。让运行时问题减少,安全。,
2,避免了强制转换麻烦。
ArrayList<String> al = new ArrayList<String>(); 定义了ArrayList容器,容器里面的元素是String类型的
避免强转:
Iterator<String> it = al.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s+":"+s.length()); }
泛型使用
泛型格式:通过<>来定义要操作的引用数据类型。在使用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 Worker { } class Studnet { } //泛型前做法 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 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 GenericDemo4 { public static void main(String[] args) { Demo<String> d = new Demo<String>(); d.show("haha"); d.show("heihei"); } }
泛型类定义的泛型,在整个类中有效。如果被方法使用,
那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。
那么可以将泛型定义在方法上。
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); */ } }
静态方法泛型
特殊之处:静态方法不可以访问类上定义的泛型。
如果静态方法操作的引 用数据类型不确定,可以将泛型定义在方法上。
类的类型的明确要等到对象的建立:
class Demo<T>中的T要等到Demo<String> d = new Demo<String>()时才会变成String,但是static声明的泛型在class存在的时候就已经存在在内存中的方法区中了。它存在的时候还没有对象。
泛型的定义放在返回值得前面,修饰符的后面。
泛型接口
//泛型定义在接口上。 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(4); //InterImpl i = new InterImpl(); //i.show("haha"); } }
泛型限定
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("abc1"); al.add("abc2"); al.add("abc3"); ArrayList<Integer> al1 = new ArrayList<Integer>(); al1.add(4); al1.add(7); al1.add(1); printColl(al); printColl(al1); */ ArrayList<Person> al = new ArrayList<Person>(); al.add(new Person("abc1")); al.add(new Person("abc2")); al.add(new Person("abc3")); //printColl(al); 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()); } } /* public static void printColl(ArrayList<?> al)//ArrayList al = new ArrayList<Integer>();error { Iterator<?> it = al.iterator(); while(it.hasNext()) { System.out.println(it.next().toString()); } } */ } 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 Student implements Comparable<Person>//<? super E> { public int compareTo(Person s) { this.getName() } } */ class Comp implements Comparator<Person> { public int compare(Person s1,Person s2) { //Person s1 = new Student("abc1"); return s1.getName().compareTo(s2.getName()); } } TreeSet<Student> ts = new TreeSet<Student>(new Comp()); ts.add(new Student("abc1")); ts.add(new Student("abc2")); ts.add(new Student("abc3"));
泛型限定super
import java.util.*; 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("abc06")); ts.add(new Student("abc01")); 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("wabc--03")); ts1.add(new Worker("wabc--02")); ts1.add(new Worker("wabc--06")); ts1.add(new Worker("wabc--01")); Iterator<Worker> it1 = ts1.iterator(); while(it1.hasNext()) { System.out.println(it1.next().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 Comp implements Comparator<Person> { public int compare(Person p1,Person p2) { return p2.getName().compareTo(p1.getName()); } } 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); } }
-------android培训、java培训、java学习型技术博客、期待与您交流!
----------
相关文章推荐
- 黑马程序员_java基础6-集合框架Collection和泛型
- 41.黑马程序员-集合框架、泛型
- 黑马程序员_JAVA笔记15——集合框架(泛型)
- 黑马程序员——集合框架&List
- 每天一读之 < Java 泛型与集合框架 >
- 黑马程序员—9、JAVA基础&集合框架
- 黑马程序员---集合框架<泛型>
- 黑马程序员------List<>泛型集合
- 黑马程序员_集合框架(泛型)
- 黑马程序员——集合框架&List
- 黑马程序员 Java基础<七>---> 集合框架
- 黑马程序员 java高新技术<三>--java5的注解、java5的泛型
- 黑马程序员——>第十五天<集合框架(TreeSet-泛型)>
- 黑马程序员——Java基础---泛型、集合框架工具类:collections和Arrays
- 黑马程序员——集合框架-Map&集合和数组的操作类,for-each
- 黑马程序员--11集合类的学习List&Hash&Array)Set&泛型
- 【黑马程序员】集合框架(二)泛型 第十六天
- 黑马程序员---集合框架(Collection)和泛型
- 黑马程序员_<<GUI(图形用户管理)-----2>>
- 黑马程序员——注解&泛型