12 Java基础集合框架

最新推荐文章于 2021-11-15 20:26:49 发布

jingruoas

最新推荐文章于 2021-11-15 20:26:49 发布

阅读量215

点赞数

分类专栏： Java 笔记

本文链接：https://blog.csdn.net/jingruoas/article/details/50265727

版权

Java 笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

数组是固定长度的，集合的长度是可变的
集合的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就用集合容器进行存储
集合特点：
1 用于存储对象的容器
2 集合的长度是可变的
3 集合中不可以存储基本数据类型值
*/
集合容器因为内部的数据结构不同，有多种具体容器。
不断向上抽取，就形成了集合框架。

框架的顶层Collection接口：

Collection的常见方法：
1 添加

boolean add(E e) //E就是object

boolean addAll(Collection<? extends E> c) 将指定 collection 中的所有元素都添加到此 collection 中（

2删除

boolean remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
void clear()移除此 collection 中的所有元素（可选操作）。

3 判断
boolean contains(Object o) 如果此 collection 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。

4 获取
int size()
返回此 collection 中的元素数。
Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。

该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可
也就是iterator方法。
Iterator接口就是对所有的collection容器进行元素取出的公共接口
5 其他
boolean retainAll(Collection<?> c) 取交集
仅保留此 collection 中那些也包含在指定 collection 的元素
Object[]
toArray() 将集合转成数组
返回包含此 collection 中所有元素的数组。

Colletion
|---List：有序（存入和取出的顺序一致），元素都有索引（角标），元素可以重复
|---Set：元素不能重复，可能无序。
List:特有的常见方法：有一个共性特点就是都可以操作角标。
1，添加
void add(index,element)
void add(index,collection)

2，删除
Object remove(index)

3，修改
Object set(index,element);

4，获取
Object get(index)
int indexOf(object);
int lastIndexOf(object)
List subList(from,to);

list集合是可以完成对元素的增删改查

List:
|--Vector:内部是数组结构，是同步的。增删查询都很慢。
|--ArrayList：内部是数组结构，是不同步的。替代了vector。查询速度快
|--LinkedList:内部是链表数据结构。是不同步的。增删速度很快。

集合框架
Collection接口
子类接口：List Set
子类：Arraylist Likedlist Vector Hashset Treeset

为什么会出现这么多容器因为每一个容器对数据的存储方式都不同
这个存储方式称之为：数据结构

1 add方法的参数类型是Object 以便于接受任意类型的对象
2 集合中存储的都是对象的引用（地址）

什么是迭代器？
其实就是集合取出元素的方式

*/

import java.util.*;

class Collectiondemo
{
public static void main(String[] args)
{
// base_method1();
// base_method();
method_get();
}

public static void method_get()
{
ArrayList al=new ArrayList();
//1 添加元素
al.add("java01");
al.add("java02");
al.add("java05");
al.add("java06");

sop(al);

/*Iterator it=al.iterator();//获取迭代器：用于取出集合中的元素
while(it.hasnext()/*有元素返回真*/)
{
sop(it.next());//返回元素
}//it指向对象使用完对象不会消失仍存在内存中
*/
for (Iterator it=al.iterator(); it.hasnext(); )
{
sop(it.next());
}
}
public static void base_method1()
{

//创建一个集合容器。使用Collection接口中的子类Arraylist
ArrayList al1=new ArrayList();
//1 添加元素
al1.add("java01");
al1.add("java02");
al1.add("java05");
al1.add("java06");

ArrayList al2=new ArrayList();
//1 添加元素
al2.add("java01");
al2.add("java02");
al2.add("java03");
al2.add("java04");

al1.retainAll(al2);//取交集
sop("al1"+al1);
sop("al2"+al2);
al1.removeAll(al2);//移除相同元素
sop("al1"+al1);
sop("al2"+al2);

}
public static void base_method()
{
ArrayList al1=new ArrayList();
//1 添加元素
al1.add("java01");
al1.add("java02");
al1.add("java05");
al1.add("java06");
//打印原集合
sop(al1);
//获取个数集合长度
sop("size:"+al1.size());

//判断元素
sop("java03是否存在"+al1.contains("java03"));
sop("集合是否为空"+al1.isEmpty());
//删除元素
al1.remove("java02");

//打印改变后的集合
sop(al1);

al1.clear();//清空集合

//打印改变后的集合
sop(al1);
sop("集合是否为空"+al1.isEmpty());
}
public static void sop(Object obj)
{
System.out.println(obj);
}

}

/*
Collection
|--List:元素是有序的元素可以重复因为该集合体系有索引
|--ArrayList:底层的数据结构使用的是数组结构特点：查询速度很快但是增删稍慢。线程不同步
|--LinkedList：底层使用的链表数据结构特点：增删的速度很快查询稍慢。
|--Vector:底层是数组数据结构。线程同步。被ArrayList取代了。

|--Set 元素是无序的不可以重复

List:
特有方法。凡是可以操作角标的方法都是该体系特有的方法

增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();

List集合特有的迭代器 ListIterator是Iterator的子接口
在迭代时不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException异常

所以，在迭代时，只能用迭代器的方法操作元素可是Iterator方法是有限的
只能对元素进行判断取出删除的操作
如果想要其他的操作如添加修改等就需要使用其子接口 ListIterator

该接口只能通过List集合的ListIterator方法获取
*/
import java.util.*;
class Listdemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//method();
ArrayList al =new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");

sop(al);

for (ListIterator li=al.listIterator(); li.hasNext(); )
{
Object obj=li.next();
if (obj.equals("java02"))
{
//li.add("java009");
li.set("java006");
}
//sop("hasNext():"+li.hasNext());
//sop("hasPrevious():"+li.hasPrevious());
}
sop(al);

/*

//为什么不执行？？还是有问题？？
for (ListIterator li=al.listIterator(); li.hasPrevious(); )
{
Object obj=li.next();
if (obj.equals("java01"))
{
li.set("java005");
}
sop("pre:"+li.hasPrevious());
}
sop(al);
*/
/*
//在迭代过程中准备添加或删除元素
for (Iterator it=al.iterator();it.hasNext() ; )
{
sop("next:"+it.next());
Object obj=it.next();
if (obj.equals("java02"))//
{
//al.add("java008");//不能用集合方法
it.remove();//将Java02的引用在集合中删除

}
sop("obj="+obj);
}
sop(al);
*/
}
public static void method()
{
ArrayList al =new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");

sop("原集合是："+al);
//在指定位置添加元素
al.add(1,"java09");
//删除指定位置的元素
al.remove(2);
//修改元素
al.set(2,"java007");
//通过角标获取元素
sop("get(1):"+al.get(1));
sop(al);
//获取所有元素
/* for ( int x=0;x<al.size() ;x++ )
{
System.out.println("al("+x+")="+al.get(x));
}
*/
for (Iterator it=al.iterator();it.hasNext() ; )
{
sop("next:"+it.next());
}
//根据indexof获取对象的位置
sop("index="+al.indexOf("java02"));
List sub=al.subList(1,3);//包含头不包含尾
sop("sub="+sub);
}
public static void method1()
{

}
}

/*
将自定义对象作为元素存到ArrayList集合中并去除重复元素

List集合判断元素是否相同依据的是元素的equals方法

*/

import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}

public boolean equals(Object obj)//Person类的equals方法
{

if (!(obj instanceof Person))
{
return false;
}
Person p=(Person)obj;

//System.out.println(this.name+"------"+p.name);
return this.name.equals(p.name) && this.age==p.age;//字符串的equals方法
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class ArrayListtest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj=new Person("lisi01",30);
al.add(new Person("lisi02",32));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35));

// al=singleElement(al);

sop("remove 03: "+al.remove(new Person("lisi03",33)));//remove ,contains等底层都要调用equals

Iterator it =al.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
sop(p.getName()+":::"+p.getAge());
}

}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器
ArrayList newal=new ArrayList();
Iterator it =al.iterator();
while(it.hasNext())
{
Object obj=it.next();//记下这个元素
if (!newal.contains(obj))//判断这个元素
{
newal.add(obj);
}
}
return newal;
}
}

import java.util.*;
/*

面试
addFirst();
addLast();

getFirst();
getLast();
获取元素但不删除元素
removeFirst();
removeLast();
获取元素但元素被删除.如果集合中没有元素会出现NoSuchElementException

在JDK1.6中出现了代替方法

offerFirsst();
offerLast();

peekFirst();
peekLast();
获取元素，但是元素不删除。如果集合中没有元素会返回null
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素会返回null
*/
class LinkedListdemo
{
public static void main(String[] args)
{
LinkedList link=new LinkedList();
/* link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
*/
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
sop(link);
// sop(link.getFirst());
// sop(link.getFirst());
//sop(link.getLast());
// sop(link.removeFirst());
// sop(link.removeFirst());
// sop("size"+link.size());

while(!link.isEmpty())
{
sop(link.removeLast());
sop("size"+link.size());

}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

/*
使用LinkedList模拟一个堆栈或者对列数据结构

堆栈：先进后出如同一个杯子
队列：先进先出 First in First out FIFO 如同一个水管

要求必须会

*/

import java.util.*;
class Duilie
{
private LinkedList link;
Duilie()
{
link=new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()//????
{
return link.removeLast();//先进先出 removeFirst 先进后出
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListtest
{
public static void main(String[] args)
{
Duilie di=new Duilie();
di.myAdd("java01");
di.myAdd("java02");
di.myAdd("java03");
di.myAdd("java04");

while(!di.isNull())
{
System.out.println(di.myGet());
}
}
}

/*
去除Arraylist中的重复元素

*/
import java.util.*;

class LinkedListtest1
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
/*
在迭代时循环中next调用一次就要hasNext判断一次
Iterator it =al.iterator();
while(it.hasNext())
{
sop(it.next()+"-----"+it.next());
}
*/
sop(al);
al=singleElement(al);
sop(al);
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器
ArrayList newal=new ArrayList();
Iterator it =al.iterator();
while(it.hasNext())
{
Object obj=it.next();//记下这个元素
if (!newal.contains(obj))//判断这个元素
{
newal.add(obj);
}
}
return newal;
}
}

import java.util.*;
/*
枚举就是Vector特有的取出方式
发现枚举和迭代器很像
其实枚举和迭代器很像

因为枚举的名称以及方法的名称都过长
所以被迭代器取代了
枚举郁郁而终了

*/
class Vectordemo
{
public static void main(String[] args)
{
Vector v= new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

Enumeration en= v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}

import java.util.*;
/*
往hashSet集合中存入自定义对象

*/

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("a4",14));
hs.add(new Person("a3",13));

sop("a1:" +hs.contains(new Person("a2",12)));
hs.remove(new Person("a4",14));
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*39;//乘以一个值保证hashCode不同
}
public boolean equals(Object obj)//Person类的equals方法
{

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;//字符串的equals方法
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

/*面试
Set:元素是无序的（存入和取出的顺序不一定一致）元素不可以重复
|---HashSet:底层数据结构是哈希表线程时非同步的
HashSet是如何保证元素唯一性的？
是通过元素的两个方法，hashCode和equals来完成
如果元素的HashCode值相同，才会判断equals是否为true
如果元素的HashCode值不同，不会调用equals

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法
|---TreeSet:可以对Set集合中的元素进行排序。
底层结构是二叉树
保证元素唯一性的依据
compareTo方法 return 0

TreeSet排序的第一种方式：让元素自身具备比较性
元素需要实现compareTo接口，覆盖compareTo方法
这种方式也称为元素的自然顺序，或者叫做默认顺序。

TreeSet排序的第二种方式：
当元素自身不具备比较性时或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式

记住排序时当主要条件相同时一定要判断一下次要条件
*/
import java.util.*;
class TreeSetdemo
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet();

ts.add(new Student("lisi02",22));//自动排序
ts.add(new Student("lisi007",18));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi007",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)
{
//return 1;//怎么存进去怎么取出来
//return -1;//倒序
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;
}
}

/*
当元素自身不具备比较性时或者具备的比较性不是所需要的
这时就需要让容器自身具备比较性
定义了比较器将比较器对象作为参数传递给TreeSet集合的构造函数

当两种排序都存在时以比较器为主
定义一个类实现Comparator接口覆盖compare方法
*/

import java.util.*;
class TreeSetdemo1
{
public static void main(String[] args)
{

TreeSet ts=new TreeSet(new Mycompare());

ts.add(new Student("lisi02",22));//自动排序
ts.add(new Student("lisi007",18));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi007",30));

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)
{
//return 1;//怎么存进去怎么取出来
//return -1;//倒序

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 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;
}
}

/*
练习：按照字符串长度排序

字符串本身具备比较性。但是他的比较方式不是所需要的。

这时就只能使用比较器。

*/

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;

}
}

/*
泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

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

泛型格式：通过<>来定义要操作的引用数据类型
在使用Java提供的对象时什么时候写泛型？

通常在集合框架中很常见
只要见到<>就要定义泛型

其实<>就是用来接收类型的。

当使用集合时将集合中要存储的数据类型作为参数传递到<>即可
*/

import java.util.*;

class Genericdemo
{
public static void main(String[] args)
{
/*
int[] arr=new int[3];

arr[0]=4;
arr[1]=3.5;//报错

//数组明确类型
*/
ArrayList<String> al=new ArrayList<String>();//明确String类型用"<>"

al.add("abc01");
al.add("abc0991");
al.add("abc014");

//al.add(4);//al.add(new Integer(4));编译失败

Iterator<String> it=al.iterator();
while(it.hasNext())
{
String s =it.next();
System.out.println(s+":"+s.length());
}
}
}

import java.util.*;

class Genericdemo1
{
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+":"+s.length());
}
}
}

class LenComparator implements Comparator<String>//安长度排序
{
public int compare(String o1,String o2)
{
int num=new Integer(o1.length()).compareTo(new Integer(o2.length()));//将o1与o2调换位置长的在上面
if(num==0)
return o2.compareTo(o1);
return num;

}
}

/*
什么时候定义泛型

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

class Genericdemo2
{
public static void main(String[] args)
{

Utils<Worker> u=new Utils<Worker>();

u.setObject(new Student());
Worker w =u.getObject();
/*
Tool t=new Tool();
t.setObject(new Worker());
Worker w=(Worker)t.getObject();
*/
}
}
class Worker
{
}
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 Worker getWorker ()
{
return w;
}

*/
}

/*泛型类定义的泛型，在整个类中有效。如果被方法使用
那么泛型类的对象明确要操作的具体类型后，所有方法要操作的类型就已经固定了

为了让不同方法可以操作不同类型而且类型还不确定
那么可以将泛型定义在方法上

特殊之处：
静态方法不可以访问类上定义的泛型
如果静态方法操作的应用数据类型不确定。可以将泛型定义在方法上

泛型定义在方法上放在返回值类型前面
*/

class Genericdemo3
{
public static void main(String[] args)
{
/*
demo<Integer> d=new demo<Integer>();

d.show(new Integer(4));
d.print(9);
demo<String> d1=new demo<String>();
d1.print("haha");
d1.show("5");
*/
demo d =new demo();
d.show("haha");
d.show(new Integer(4));
d.print("haha");
demo.method("hhhhhhhhhh");
}
}
/*
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);
}
public static <W> void method(W t)
{
System.out.println("method:"+t);
}
}

//泛型定义在接口上

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 Genericdemo4
{
public static void main(String[] args)
{
// Interimpl i=new Interimpl();
// i.show("haha");
Interimpl<Integer> i=new Interimpl<Integer>();
i.show(4);
}
}

/*
?通配符也可以理解为占位符
泛型的限定：
? extends E：可以接受E类型或者E的子类型。上限。
？super E：可以接受E类型或者E的父类型。下限。

*/
import java.util.*;

class Genericdemo5
{
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>();//ArrayList<Person> al= ArrayList<Student>();出现安全问题左右两边要一致
al1.add(new Student("abc--1"));
al1.add(new Student("abc--2"));
al1.add(new Student("abc--3"));
printColl(al1);
}
public static void printColl(ArrayList<? extends Person> al)//? extends泛型限定
{
Iterator<? extends Person> it=al.iterator();
while(it.hasNext())
{

System.out.println(it.next().getName());
}
}
/*
public static void printColl(ArrayList<?> al)//<?>通配符不明确具体类型。 T代表具体类型
{
Iterator<?> it=al.iterator();
while(it.hasNext())
{

System.out.println(it.next());//System.out.println(it.next().length());//不可以具体类型
}

}
*/
}
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<Student>
{
public int compare(Student s1,Student s2)//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"));

/*

*/
import java.util.*;

class Genericdemo6
{
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("abc--------03"));
ts1.add(new Worker("abc--------02"));
ts1.add(new Worker("abc--------06"));
ts1.add(new Worker("abc--------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);
}
}

jingruoas

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
12 Java基础集合框架

数组是固定长度的，集合的长度是可变的集合的由来：对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就用集合容器进行存储集合特点：1 用于存储对象的容器2 集合的长度是可变的3 集合中不可以存储基本数据类型值*/集合容器因为内部的数据结构不同，有多种具体容器。不断向上抽取，就形成了集合框架。框架的顶层Collection接口：
复制链接

扫一扫