------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员 java 基础 毕向东 面向对象 集合框架
1：集合Collection概述 and 共性方法 and 迭代器引述
集合存储地址
package day14Collection;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 1:
1：add方法的参数类型是Object(泛型)
以便于接收任意类型对象。
2：集合中存储的都是对象的引用 (地址)
什么是迭代器呢？
集合取出元素的方式
*/
public class CollectionDemo {
public static void main(String[] args) {
// methon_2();
methon_get();
}
static void sop(Object o){
System.out.println(o);
}
static void methon_get(){
ArrayList a1=new ArrayList();
a1.add("java1");
a1.add("java1");
a1.add("java2");
a1.add("java3");
a1.add("java4");
/*------------------------------------*/
Iterator it=a1.iterator();
/*
* 获取迭代器，用于获取集合 的元素
*
* */
while (it.hasNext()) {
sop(it.next());
}
sop("=================");
/*------------------------------------*/
for (Object object : a1) {
sop(object);
}
/*------------------------------------*/
sop("=================");
//相比于while for循环在运行结束后 迭代器对象被释放
for (Iterator iterator = a1.iterator(); iterator.hasNext();) {
sop(iterator.next());
}
/*------------------------------------*/
}
static void methon_2(){
ArrayList a1=new ArrayList();
a1.add("java1");
a1.add("java1");
a1.add("java2");
a1.add("java3");
a1.add("java4");
ArrayList a2=new ArrayList();
a2.add("java1");
a2.add("java2");
// a2.add("java3");
a2.add("java4");
// sop("a1"+a1);
// sop("a2"+a2);
// sop(a1.retainAll(a2));//取交集，保留a2中存在的元素
// sop("a1"+a1);
// sop("a2"+a2);
/*-----------------------------------*/
// sop("a1"+a1);
// sop("a2"+a2);
// sop(a1.removeAll(a2));//取交集，保留a2中存在的元素
// sop("a1"+a1);
// sop("a2"+a2);
/*-----------------------------------*/
sop("a1"+a1);
sop("a2"+a2);
sop(a1.addAll(a2));//取交集，保留a2中存在的元素
sop("a1"+a1);
sop("a2"+a2);
}
static void methon_base(){
//创建一个集合容器，使用Collection接口子类ArrayList
ArrayList arrayList1=new ArrayList();
// 1 添加元素
arrayList1.add("java1");
arrayList1.add("java1");
arrayList1.add("java2");
arrayList1.add("java3");
arrayList1.add("java4");
arrayList1.add(1);
//打印集合
sop(arrayList1);
//2获取个数，集合长度
sop("arrayList1.size():"+arrayList1.size());
//3 删除 元素
arrayList1.remove("java1");
sop("delete："+arrayList1);
// arrayList1.clear();
// sop("clear："+arrayList1);
//4 判断元素
sop("java1是否存在"+arrayList1.contains("java1"));
sop(arrayList1);
arrayList1.clear();
sop("集合是否为空"+arrayList1.isEmpty());
sop(arrayList1);
}
}
2 Collection---->List 类 特点 和 增删查改方法 and 特有迭代器ListIterator
package day14Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo {
/*
* Collection
* |--List:特点：元素是有序，同时元素可以重复。因为该集合体系有索引
* |--ArrayList ：底层的数据结构使用数组结构：特点在于查询速度快，增、删、插入麻烦 。线程不同步
* |--LinkedList：底层使用链表数据结构:特点：增删快，查询慢
* |--Vector ：底层是数组数据结构。Vector是同步的。被ArrayList 替代
* |--Set 特点：元素是无序，同时元素不可以重复。因为该集合体系没有索引
*List 特有方法：凡是可以操作角标的方法都是该体系特有方法
*增 add（inde.element）
* add(index,Collection)
*删 remove(index)
*改set(index,element)
*查get(index）
* subList（from,to）
* listIterator();
*
*list 集合特有的迭代器
*ListIterator 是Iterator的子接口
*在迭代时不可以通过集合 对象的方法操作集合中的元素
*因为会发生集合并发修改异常
*所以需要在迭代时只能用迭代器的方法操作元素
*可以Iterator的操作方法有限，只能进行判断取出删除的操作
*如果要添加，修改等操作，就应该使用其子接口ListIterator
*该接口只能通过List结合的listIterator（）获取
*实现在遍历过程中修改等
* */
public static void main(String[] args) {
//演示列表迭代器
ArrayList a1=new ArrayList();
a1.add("java22");
a1.add("java23");
a1.add("java24");
a1.add("java25");
//在迭代过程中，准备往列表中添加或者删除元素
// Iterator it=a1.iterator();
/*
while (it.hasNext()) {
Object object = (Object) it.next();
if (object.equals("java22")) {
a1.add("java08");
// java.util.ConcurrentModificationException 并发修改异常
}
}
*/
sop(a1);
// while (it.hasNext()) {
// Object object = (Object) it.next();
// if (object.equals("java22")) {
// //将java22的引用从集合中删除了
// it.remove();
// }
// }
// sop(a1);
ListIterator li=a1.listIterator();
while (li.hasNext()) {
Object object=li.next();
if (object.equals("java22")) {
// li.add("java009");
li.set("java009");
}
}
while (li.hasPrevious()) {
Object object = (Object) li.previous();
sop(object);
}
sop("hasNext:"+li.hasNext());
sop("hasPrevious:"+li.hasPrevious());
sop("hasNext:"+li.hasNext());
sop(a1);
}
static void method(){
ArrayList a1=new ArrayList();
//添加元素
a1.add("java11");
a1.add("java12");
a1.add("java13");
sop("原来集合"+a1);
//在指定位置添加元素
a1.add(2,"java2");
sop("添加后集合"+a1);
//删除指定位置的元素
a1.remove(1);
sop("删除后集合"+a1);
//修改元素
a1.set(2, "java111");
sop("修改后集合"+a1);
//通过角标获取
a1.get(1);
sop(a1.get(1));
//获取所有元素
for (int i = 0; i < a1.size(); i++) {
sop("a1.get(i):--》"+a1.get(i));
}
for (Iterator iterator = a1.iterator(); iterator.hasNext();) {
sop(iterator.next());
}
//通过indexOf 获取对象位置
sop("a1.indexOf(java11)"+a1.indexOf("java11"));
//通过subList 获取子List
List l2=a1.subList(0,2);
sop("a1.subList(1,2)"+a1.subList(0,2));
}
static void sop(Object o){
System.out.println(o);
}
}
3 Vector 中枚举
package day14Collection;
import java.util.Enumeration;
import java.util.Vector;
/*
* 枚举 就是Vector的特有取出方式
* 迭代器
* 枚举
* get
* 发现枚举和迭代器很像
* 其实两者是一样的
*
* 因为枚举的名称和方法名过长
* 所以被迭代器取代了
* 枚举郁郁而终*/
public class VectorDemo {
public static void main(String[] args) {
Vector vector=new Vector();
vector.add("java1");
vector.add("java2");
vector.add("java3");
sop(vector);
Enumeration e=vector.elements();
while (e.hasMoreElements()) {
Object object = (Object) e.nextElement();
sop(object);
}
}
static void sop(Object o){
System.out.println(o);
}
}
4 Collection-->List -->LinkedList 介绍
package day14Collection;
import java.util.Iterator;
import java.util.LinkedList;
/*
* LinkedList 特有方法
* addFrist();
* addLaot();
*
* getFirst();
* getLast（）；
* 获取元素。但不删除元素
*
* removeFirst();
* removeLast();
* 获取元素，并删除元素
* 如果集合中没有元素，抛出NoSuchElementException
* 在jdk 1.6 之后出现了替代
* pollFirst（）
*
* peekFirst（）;
* offerFirst
* */
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList l=new LinkedList();
l.add(1);
l.add(2);
l.add(3);
l.add(4);
l.addFirst("add Frist");
sop(l);
sop("l.getFirst():"+l.getFirst());
sop("l.get(2):"+l.get(2));
sop(l.removeFirst());
sop(l.size());
// while (!l.isEmpty()) {
// sop("l.removeFirst()"+l.removeFirst());
// }
sop("------");
for (Iterator iterator = l.iterator(); iterator.hasNext();) {
Object object = (Object) iterator.next();
sop("object:"+object);
}
}
static void sop(Object o){
System.out.println(o);
}
}
5 LinkedList 练习
package day14Collection;
import java.util.LinkedList;
public class LinkedListTest {
/*
* 使用LinkedList
* 模拟堆栈或者队列数据结构
*
* 堆栈：先进后出 如同杯子
* 队列：先进先出 如同管道*/
public static void main(String[] args) {
Duilie duilie=new Duilie();
duilie.addFirst("java1");
duilie.addFirst("java2");
duilie.addFirst("java3");
duilie.addFirst("java4");
sop(duilie.getLast());
while (!duilie.isEmpty()) {
sop(duilie.getLast());
}
}
static void sop(Object o){
System.out.println(o);
}
}
class Duilie{
private LinkedList link;
public Duilie() {
link=new LinkedList();
}
public void addFirst(Object o) {
link.addFirst(o);
}
public Object getLast() {
return link.removeLast();
}
public boolean isEmpty() {
return link.isEmpty();
}
}
6 ArrayList 练习 去掉重复元素if (!newAl.contains(object)) {newAl.add(object);}
<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;">package day14Collection;</span>
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTest {
/*
* 去除ArrayList中的重复元素*/
public static void main(String[] args) {
ArrayList arrayList=new ArrayList();
arrayList.add("java1");
arrayList.add("java1");
arrayList.add("java1");
arrayList.add("java2");
arrayList.add("java3");
arrayList.add("java4");
Iterator i=arrayList.iterator();
while (i.hasNext()) {
Object object = (Object) i.next();
sop(i.next());
//迭代时 循环中 只调用一次，就用hasNext 判断一次
}
/*
* */
sop(arrayList);
sop(singleElement(arrayList));
}
public static ArrayList singleElement(ArrayList al) {
ArrayList newAl=new ArrayList();
Iterator i=al.iterator();
while (i.hasNext()) {
Object object = (Object) i.next();
sop(object);
if (!newAl.contains(object)) {
newAl.add(object);
}
}
return newAl;
}
static void sop(Object o){
System.out.println(o);
}
}
7 ArrayList 练习 自定义要存储的对象 and 去除重复元素（核心：集合判断元素是否相同，依据就是元素的equals方法）
package day14Collection;
import java.util.ArrayList;
import java.util.Iterator;
import com.sun.org.apache.bcel.internal.generic.NEW;
public class ArrayListTest2 {
/*
* 将 自定义对象作为元素
* 存储到ArrayLIst集合中
* 并去除重复元素
* 比如 人对象，同姓名同年龄看做重复
*
* 思路：
* 1：对人描述，将数据封装
* 2：定义容器，存入
* 3：去除重复
* List 集合判断元素是否相同，依据就是元素的equals方法
* */
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add(new Person2("lisi1", 31));
al.add(new Person2("lisi1", 31));
al.add(new Person2("lisi2", 32));
al.add(new Person2("lisi3", 33));
al.add(new Person2("lisi4", 34));
al =singleElement(al);
Iterator iterator=al.iterator();
while (iterator.hasNext()) {
Person2 person2 = (Person2) iterator.next();
sop("person2.getName():"+person2.getName()+"person2.getAge():"+person2.getAge());
}
sop("al.remove new :"+al.remove(new Person2("lisi1", 31)));
}
static void sop(Object o){
System.out.println(o);
}
public static ArrayList singleElement(ArrayList al) {
ArrayList newAl=new ArrayList();
Iterator i=al.iterator();
while (i.hasNext()) {
Person2 p = (Person2) i.next();
// sop(p);
System.out.println("------->contains");
if (!newAl.contains(p)) {
newAl.add(p);
}
}
return newAl;
}
}
class Person2{
private String name;
private int age;
public Person2(String name,int age) {
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean equals(Object object) {
System.out.println("---->equals");
if(!(object instanceof Person2)) {
return false;
}
Person2 p=(Person2) object;
return this.name.equals(p.getName())&&this.name==(p.getName());
}
}
8 HashSet 简介（元素唯一，无序，底层数据结构为哈希表）
package day14Collection;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
/**
* --Set 特点：元素是无序，同时元素不可以重复。因为该集合体系没有索引
* |--HashSet：底层数据结构式哈希表
* |--TreeSet：
* 元素无序 ：也就是存入和取出元素的顺序不一定一致，元素不可以重复
*set 集合的功能和Collection 是一致的
*
*/
public static void main(String[] args) {
// Demo d1=new Demo();
// Demo d2=new Demo();
// sop(d1);
// sop(d2);
HashSet hs=new HashSet();
sop(hs.add("java01"));
sop(hs.add("java01"));
hs.add("java01");
hs.add("java02");
hs.add("java03");
hs.add("java04");
for (Iterator iterator = hs.iterator(); iterator.hasNext();) {
Object object = (Object) iterator.next();
sop("hs:"+object);
}
}
static void sop(Object o){
System.out.println(o);
}
}
//class Demo{
// public int hashCode() {
// return 60;
//
// }
//}
9 Hashset 练习 存入自定义对象 年龄相同视为相同元素（核心：HashSet 实现元素唯一的原理依赖于 hashCode() 和 equals（））
package day14Collection;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetTest {
/**
*向HashSet 存入自定义对象
*姓名年龄相同视为相同元素
*
* HashSet 如何保证元素唯一性的呢？？？
*通过元素是两个方法看，hashCode 和equals方法
*如果hashCode相同，会判断equals是否为true
*如果hashCode不同，不会调用equals
在java的集合中，判断两个对象是否相等的规则是：
1:判断两个对象的hashCode是否相等
如果不相等，认为两个对象也不相等，完毕
如果相等，转入2)
2:判断两个对象用equals运算是否相等
如果不相等，认为两个对象也不相等
如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）
注意：
对于元素是否存在，已经删除操作。
依赖的方法是：hashCode和equals方法
ArrayList 依赖equals
而Hashset 依赖 hashCode和equals
*/
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add(new Person3("a1",11));
hs.add(new Person3("a2",12));
hs.add(new Person3("a3",13));
sop("-->"+hs.contains(new Person3("a2",12)));
sop("remove:--->"+hs.remove(new Person3("a2",12)));
sop("remove:--->"+hs.remove(new Person3("a3",13)));
sop("remove:--->"+hs.remove(new Person3("a1",11)));
for (Iterator iterator = hs.iterator(); iterator.hasNext();) {
Person3 object = (Person3) iterator.next();
sop("object.getName():"+object.getName()+"---object.getAge():"+object.getAge());
}
}
static void sop(Object o){
System.out.println(o);
}
}
class Person3{
private String name;
private int age;
public Person3(String name,int age) {
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean equals(Object object) {
System.out.println(this.name+"---->equals"+this.age);
if(!(object instanceof Person3)) {
return false;
}
Person3 p=(Person3) object;
return this.name.equals(p.getName())&&this.age==p.getAge();
}
// public boolean equals(Object obj) {
// System.out.println("equals:>>this："+this+"---obj"+obj);
// return (this == obj);
// }
public int hashCode() {
System.out.println("hashCode:>>"+this.name+"--------"+this.age);
return 60;
}
}
10 TreeSet 有序 ，唯一，底层数据结构为二叉树/红黑树 ；存入的对象需要实现Comparable接口 或者 TreeSet（Compartor c）唯一依赖于compareTo 方法 return 0
</pre><pre code_snippet_id="471367" snippet_file_name="blog_20140919_12_4620803" name="code" class="java">package day14Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo {
/*
* Set 无序 不可以重复
* |————Hashset ：数据结构式哈希表，线程非同步
* 保证元素唯一性的原理是：
* 判断元素的hashCode是否相同
* 如果相同，判断equals方法
* |————TresSet:
* 可以对set集合中的元素进行排序
* 底层数据结构二叉树
* 保证元素唯一性的依据是：
* compareTo 方法 return 0；
* TreeSet 排序方式是
* 让元素自身具有比较性
* 元素需要实现Comparable接口
* 覆盖CompareTo 方法
* 这种方式也称为元素 是自然顺序或者默认顺序。
*
* TreeSet第二种排序方式
* 当元素自身不具备比较性时，或者具备的不是不是需要的比较性时：
* 这是需要让集合本身具有比较性
* 在集合初始化时具有比较方式
* 让让排序参与构造函数
*
* 需求：
* 向TreeSet集合中存储自定义对象 学生
* 想按照学生的年龄进行排序
* Treeset排序时：
* 当主要条件相同时，一定判断一下次要条件
*
* 怎么存 然后怎么取：
* 将CompareTo（Object c）{
* return 1；
* }
*
* */
public static void main(String[] args) {
TreeSet ts=new TreeSet();
// ts.add("cba");
// ts.add("abcd");
// ts.add("aaa");
// ts.add("bca");
// ts.add("2");
// ts.add("1");
sop(ts.add(new Student("lisi1",22)));
sop(ts.add(new Student("lisi2",23)));
sop(ts.add(new Student("lisi3",24)));
sop(ts.add(new Student("lisi4",24)));
sop(ts.add(new Student("lisi4",24)));
/* java.lang.ClassCastException:
* day14Collection.Student
cannot be cast to java.lang.Comparable*/
for (Iterator iterator = ts.iterator(); iterator.hasNext();) {
Student object = (Student) iterator.next();
sop("getAge:"+object.getAge()+"--getName:"+object.getName());
}
}
static void sop(Object o){
System.out.println(o);
}
}
class Student implements Comparable{
//Comparable 让实现它的类具有比较性
private String name;
private int age;
public Student(String name,int age) {
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Object o) {
if(!(o instanceof Student))
throw new RuntimeException("不是学生对象");
Student s=(Student) o;
System.out.println(this.name+":compara:"+s.name);
if(this.age>s.getAge())
return 1;
else{
if(this.age<s.getAge())
return -1;
}
return this.name.compareTo(s.name);
}
}
11 TreeSet 当元素自身不具备比较性 或者具备的不是需要的比较性，这是让容器自身具有比较性
package day14Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo2 {
/*
* 当元素自身不具备比较性
* 或者具备的不是需要的比较性
*
* 这是让容器自身具有比较性
*
* 这时定义比较器
* 将比较器对象作为构造函数参数进行构造
*
* 当两种方式同时存在时
* 以比较器为主
* 定义一个类
* 实现Comparator接口， 实现compare方法
*
* */
public static void main(String[] args) {
TreeSet ts=new TreeSet(new MyCompare());
ts.add(new Student2("lisi02",22));
ts.add(new Student2("lisi02",21));
ts.add(new Student2("lisi007",20));
ts.add(new Student2("lisi09",19));
ts.add(new Student2("lisi06",18));
ts.add(new Student2("lisi06",18));
ts.add(new Student2("lisi007",29));
for (Iterator iterator = ts.iterator(); iterator.hasNext();) {
Student2 object = (Student2) iterator.next();
sop("getAge:"+object.getAge()+"--getName:"+object.getName());
}
}
static void sop(Object o){
System.out.println(o);
}
}
class MyCompare implements Comparator{
public int compare(Object o1, Object o2) {
Student2 s1=(Student2) o1;
Student2 s2=(Student2) o2;
int m=s1.getName().compareTo(s2.getName());
if(m==0)
return Integer.valueOf(s1.getAge()).compareTo(Integer.valueOf(s2.getAge()));
return m;
}
}
class Student2 implements Comparable{
private String name;
private int age;
public Student2(String name,int age) {
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Object o) {
if(!(o instanceof Student2))
throw new RuntimeException("不是学生对象");
Student2 s=(Student2) o;
System.out.println(this.name+":compara:"+s.name);
if(this.age>s.getAge())
return 1;
else{
if(this.age<s.getAge())
return -1;
}
return this.name.compareTo(s.name);
}
}
12 自定义对象具有比较性 存储器也具有比较性
package day14Collection;
import java.util.*;
/*
当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。
*/
class Student3 implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student3(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student3))
throw new RuntimeException("不是学生对象");
Student3 s = (Student3)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;
}
}
public class TreeSetDemo22
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare3());
ts.add(new Student3("lisi02",22));
ts.add(new Student3("lisi02",21));
ts.add(new Student3("lisi007",20));
ts.add(new Student3("lisi09",19));
ts.add(new Student3("lisi06",18));
ts.add(new Student3("lisi06",18));
ts.add(new Student3("lisi007",29));
//ts.add(new Student3("lisi007",20));
//ts.add(new Student3("lisi01",40));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student3 stu = (Student3)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class MyCompare3 implements Comparator
{
public int compare(Object o1,Object o2)
{
Student3 s1 = (Student3)o1;
Student3 s2 = (Student3)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;
}
}
13TreeSet 练习 按照字符长度进行排序
package day14Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetTest {
/*
* 练习 按照字符长度进行排序
*
* 字符串本身具有比较性
* 但是他的方式不是需要的*/
public static void main(String[] args) {
TreeSet ts=new TreeSet(new StringLengthComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("a");
ts.add("hahaha");
for (Iterator iterator = ts.iterator(); iterator.hasNext();) {
String object = (String) iterator.next();
sop(object);
}
}
static void sop(Object o){
System.out.println(o);
}
}
class StringLengthComparator 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;
}
}
14 泛型简介 类型安全机制 <> 定义
</pre></h1><div><pre code_snippet_id="471367" snippet_file_name="blog_20140919_17_3562837" name="code" class="java">package day14Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo {
/*
* 泛型
* JDK1.5版本以后出现新特性
* 用于解决安全问题，是一个类型安全机制
* 好处：
* 1:将运行时问题转移到编译时期
* 2:避免了强制转换
* 类型安全机制
*
* 泛型的格式：
* 通过 <> 定义要操作 的数据类型
*
* 在使用java对象时，何时使用泛型
* 通常在集合框架中很常见
*
* 只有见到 <> 就使用泛型
*
* 其实 <>就是定义接受类型的
*
* 当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
* */
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("abc01");
al.add("abc01");
al.add("abc01");
al.add("abc0991");
al.add("abc014");
for (Iterator<String> iterator = al.iterator(); iterator.hasNext();) {
String object = iterator.next();
sop("长度："+object.length());
}
}
static void sop(Object o){
System.out.println(o);
}
}
15 泛型Generic 示例
package day14Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo2 {
public static void main(String[] args) {
TreeSet<String> ts=new TreeSet<String>(new StringLengthComparator2());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("a");
ts.add("hahaha");
for (Iterator<String> iterator = ts.iterator(); iterator.hasNext();) {
sop( iterator.next());
}
}
static void sop(Object o){
System.out.println(o);
}
}
class StringLengthComparator2 implements Comparator<String>{
@Override
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;
}
}
15 使用泛型场景之一当 类中要操作的类类型不确定时（早期定义Object来完成扩展）
package day14Collection;
public class GenericDemo3 {
/*什么时候需要泛型
*
* 当 类中要操作的类类型不确定时
* 早期定义Object来完成扩展
*
* 现在定义泛型类来完成扩展
* */
public static void main(String[] args) {
Utils<Worker> t=new Utils<Worker>();
t.setT(new Worker());
// t.setT(new Student4());编译错误
Worker w=t.getT();
}
}
class Worker{
}
class Student4{
}
//泛型类
class Utils<T>{
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
//class Tool{
//泛型之前的做法
// private Object obj;
//
// public Object getObj() {
// return obj;
// }
//
// public void setObj(Object obj) {
// this.obj = obj;
// }
//}
//class Tool{
// private Worker w;
//
// public Worker getW() {
// return w;
// }
//
// public void setW(Worker w) {
// this.w = w;
// }
//}
16 泛型定义范围 类 or 方法
package day14Collection;
public class GenericDemo4 {
/*泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定
那么可以将泛型定义在方法上。
* */
public static void main(String[] args) {
// Demo<String> d=new Demo<String>();
// d.show("haha");
// d.print("hwhh");
Demo<Integer> d=new Demo<Integer>();
// Demo d=new Demo();
d.show(new Integer(4));
d.print(4);//自动装箱
// d.show("haha");
d.print("hwhh");
Demo.method(d);
}
}
//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 <T> void print(T t){
// System.out.println("print:"+t);
//}
//
//}
class Demo <T>{
public void show(T t){
System.out.println("show:"+t);
}
public <Q> void print(Q t){
System.out.println("print:"+t);
}
public static <W> void method(W w){
System.out.println("method:"+w);
// Cannot make a static reference to the non-static type T
//静态方法不可以方法类上定义的泛型
//如果静态操作的应用数据类型不确定 ，可以定义在方法上
}
}
17 泛型定义在接口
package day14Collection;
public class GenericDemo5 {
/*
* 泛型定义在接口上
* */
public static void main(String[] args) {
InterImpl<String> i=new InterImpl<String>();
i.show("haha");
}
}
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);
}
}
18泛型限定 范围 。向上限定 ？ extends E 可以接受E 或者E类型的子类 and 向下限定 ？ super E 可以接受E 或者E类型的父类
package day14Collection;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo6 {
/*
* ？ 通配符。占位符
* 泛型限定
*
* 向上限定 ？ extends E 可以接受E 或者E类型的子类
* 向下限定 ？ super E 可以接受E 或者E类型的父类*/
public static void main(String[] args) {
// ArrayList<String> al=new ArrayList<String>();
// al.add("abc1");
// al.add("abc2");
// al.add("abc3");
// pingtColl(al);
//
// ArrayList<Integer> all=new ArrayList<Integer>();
// all.add(3);
// all.add(2);
// all.add(1);
// pingtColl(all);//编译错误
ArrayList<Person> al=new ArrayList<Person>();
al.add(new Person("abc1"));
al.add(new Person("abc2"));
al.add(new Person("abc3"));
pingtColl(al);
ArrayList<Student5> all=new ArrayList<Student5>();
al.add(new Student5("abc1"));
al.add(new Student5("abc2"));
al.add(new Student5("abc3"));
pingtColl(all);//编译失败
}
public static void pingtColl(ArrayList<? extends Person> al) {
for (Iterator<? extends Person> iterator = al.iterator(); iterator.hasNext();) {
System.out.println("pingtColl:"+iterator.next().getName());
}
}
// public static void pingtColl(ArrayList<?> al) {
// for (Iterator<?> iterator = al.iterator(); iterator.hasNext();) {
// System.out.println("pingtColl:"+iterator.next());
//// System.out.println("pingtColl:"+iterator.next().lentgh());编译错误
// }
// }
// public static <T> void pingtColl(ArrayList<T> al) {
// for (Iterator<T> iterator = al.iterator(); iterator.hasNext();) {
//
// System.out.println("pingtColl:"+iterator.next());
// }
// }
}
class Person{
private String name;
public Person(String name){
this.name=name;
}
public String getName() {
return name;
}
}
class Student5 extends Person{
public Student5(String name){
super(name);
}
}
package day14Collection;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo6 {
/*
* ？ 通配符。占位符
* 泛型限定
*
* 向上限定 ？ extends E 可以接受E 或者E类型的子类
* 向下限定 ？ super E 可以接受E 或者E类型的父类*/
public static void main(String[] args) {
// ArrayList<String> al=new ArrayList<String>();
// al.add("abc1");
// al.add("abc2");
// al.add("abc3");
// pingtColl(al);
//
// ArrayList<Integer> all=new ArrayList<Integer>();
// all.add(3);
// all.add(2);
// all.add(1);
// pingtColl(all);//编译错误
ArrayList<Person> al=new ArrayList<Person>();
al.add(new Person("abc1"));
al.add(new Person("abc2"));
al.add(new Person("abc3"));
pingtColl(al);
ArrayList<Student5> all=new ArrayList<Student5>();
al.add(new Student5("abc1"));
al.add(new Student5("abc2"));
al.add(new Student5("abc3"));
pingtColl(all);//编译失败
}
public static void pingtColl(ArrayList<? extends Person> al) {
for (Iterator<? extends Person> iterator = al.iterator(); iterator.hasNext();) {
System.out.println("pingtColl:"+iterator.next().getName());
}
}
// public static void pingtColl(ArrayList<?> al) {
// for (Iterator<?> iterator = al.iterator(); iterator.hasNext();) {
// System.out.println("pingtColl:"+iterator.next());
//// System.out.println("pingtColl:"+iterator.next().lentgh());编译错误
// }
// }
// public static <T> void pingtColl(ArrayList<T> al) {
// for (Iterator<T> iterator = al.iterator(); iterator.hasNext();) {
//
// System.out.println("pingtColl:"+iterator.next());
// }
// }
}
class Person{
private String name;
public Person(String name){
this.name=name;
}
public String getName() {
return name;
}
}
class Student5 extends Person{
public Student5(String name){
super(name);
}
}
19 泛型限定示例
package day14Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo7 {
/*
* */
public static void main(String[] args) {
TreeSet<Student7> ts=new TreeSet<Student7>(new Comp());
ts.add(new Student7("abc3"));
ts.add(new Student7("abc2"));
ts.add(new Student7("abc6"));
ts.add(new Student7("abc1"));
ts.add(new Student7("abc3"));
for (Iterator<Student7> iterator = ts.iterator(); iterator.hasNext();) {
Student7 student7 = (Student7) iterator.next();
System.out.println(student7.getName());
}
TreeSet<Worker7> ts1=new TreeSet<Worker7>(new Comp());
ts1.add(new Worker7("abc3"));
ts1.add(new Worker7("abc2"));
ts1.add(new Worker7("abc6"));
ts1.add(new Worker7("abc1"));
ts1.add(new Worker7("abc3"));
for (Iterator<Worker7> iterator = ts1.iterator(); iterator.hasNext();) {
Worker7 w = (Worker7) iterator.next();
System.out.println(w.getName());
}
}
}
class Person7{
private String name;
public Person7(String name){
this.name=name;
}
public String getName() {
return name;
}
}
class Student7 extends Person7{
public Student7(String name){
super(name);
}
}
class Worker7 extends Person7{
public Worker7(String name) {
super(name);
}
}
class Comp implements Comparator< Person7>{
public int compare(Person7 o1, Person7 o2) {
return o1.getName().compareTo(o2.getName());
}
}
《黑马程序员 java 基础 毕向东 面向对象 集合框架》
介绍了java中的集合框架，让我对集合框架组成有了初步了解，掌握了一下集合处理方法，而泛型也是其中非常重要的部分，对于程序安全有着重要的判定作用