集合框架(体系概述)
·为什么出现集合类?
面向对象啊语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
·数组和集合类同时容器,有何不同?
数组虽然可以存储对象,但长度是固定的;集合长度是可变的。
数组中可以存储基本数据类型,集合只能存储对象。
·集合类的特点
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
为什么会出现这么多的容器?
因为每一个容器对数据的存储方式都有不同。
这个存储方式为:数据结构。
1,add方法的参数类型是Object。所以便于接受任意类型对象。
2,集合中储存的是对象的引用(地址)。
什么是迭代器?
其实就是集合的取出元素的方式。
酒吧取出方式定义在集合的内部,这样取出方式就可以直接访问集合内容的元素。
那么取出方式就被定义成了内部类。而每一个容器的数据结构不同,所以取出的动作细节也不一样。但是都有共性内容判断和取出。那么可以将这些共性抽取。
那么这些内部类都符合一个规则。该规则是Iterator。
如何获取集合的取出对象?
通过一个对外提供的方法,iterator();
-------------------------------
集合框架(共性方法)
import java.util.*;
class CollectionDemo
{
public static void method_get()
{
ArrayList al=new ArrayList();
al.add("java1");
al.add("java2");
al.add("java3");
Iterator it=al.iterator();//获取迭代器,用于取出集合中的元素。
while(it.hasNext())
{
sop(it.next());
}
/*
for(Iterator it=al.iterator();it.hasNext;)
{
sop(it.next());
}
循环结束后it对象不存在,节省空间。
*/
}
public static void method_2(String[] args)
{
ArrayList al1=new ArrayList();
al1.add("java1");
al1.add("java2");
al1.add("java3");
ArrayList al2=new ArrayList();
al2.add("java1");
al2.add("java2");
al2.add("java4");
//al1.retainAll(al2);//取交集,al1中只会保留和al2中相同的元素。
sop(al1.removeAll(al2));//删除交集,al1中只会保留和al2中不相同的元素。
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void method_1()
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al=new ArrayList();
//1,添加元素。
al.add("java1");
al.add("java2");
al.add("java3");
//打印
sop(al);//开发当中不用此方法。
//删除元素。
al.remove("java2");
sop("java3是否存在:"+al.contains("java3"));
sop("集合是否为空?"+al.isEmpty());
//清空集合
al.clear();
sop("集合是否为空?"+al.isEmpty());
//获取长度。集合长度。
sop(al.size());
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
------------------------------
集合框架(List集合共性方法)
Connection
List:元素是有序的,元素可以重复。因为该集合体系有索引。
ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快,但是增删稍慢。线程不同步。
LinkedLsit 底层使用的是链表数据结构。特点:增删的速度很快,查询稍慢。
Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
Set:元素是无序,元素不可以重复。
List:
特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,伸出操作,如果想要其他的操作,如添加,修改等,就需呀使用其子接口,ListIterator。
该接口只能通过Lits集合的listIterator方法获取。
import java.util.*;
class ListDemo
{
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("java03");
ListIterator li=al.listIterator();
sop("hasNext():"+li.hasPrevious());//false
while(li.hasNext())
{
Object obj=li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
}
while(li.hasPrevious())
{
sop("pre:"+li.previous());
}
sop("hasNext():"+li.hasNext());//false
sop("hasNext():"+li.hasPrevious());//true
sop(al);
/*
//在迭代过程中添加或者删除元素。
Iterator it=al.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(obj.equals("java02"))
//a1.add("java008");
it.remove();//将java02的引用从集合中删除了。
sop("obj="+obj);
}
*/
}
public static void method()
{
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add(1,"java09");
//删除指定未知的元素。
al.remove(2);
al.set(2,"java07");
//通过角标获取元素。
sop(al.get(1));
sop(al);
for(int x=0;x<al.size();x++)
{
System.out.println("al["+x+"]="+al.get(x));
}
Iterator it=al.iterator();
while(it.hasNext())
{
sop("next:"+it.next());
}
//通过indexOf获取对象。
sop("index="+al.indexOf("java02"));
List sub=al.subList(1,3);
sop("sub="+sub);
}
}
集合框架(Vector中的枚举)
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
*/
import java.util.*;
class ListDemo
{
public static void sop(Object obj)
{
Vector v=new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
Enumeration en=v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
--------------------------------------------
集合框架(LinkedList)
LinkedList:特有方法:
addFirst();
addLast();
getFirst();
getLast();
删除并返回元素,如果集合中没有元素会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6出现了替代方法。
添加元素
offerFirst();
offerLast();
获取元素
peekFirst();
peekLast();
删除并返回元素,如果集合中没有元素,会返回null。
pollFirst();
pollLast();
import java.util.*;
class ListDemo
{
public static void myList(Object obj)
{
LinkedList link=new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
sop(link.getFirst())
sop(link.getLast())
sop(link.removeFirst());
sop("size:"+link.size());
while(!link.isEmpty())
{
sop(link.removeFirst());
}
}
public static void sop(Object obj)
{
System.out.println(obj); }
}
------------------------
集合框架(LinkedList练习)
/*
使用LinkedList模拟一个堆栈或者对列数据结构。
堆栈:先进先出
队列:先进后出
*/
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 dl=new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
while(!dl.isNull())
{
System.out.println(dl.myGet());
}
}
}
------------------------
集合框架(ArrayList练习)去除ArrayList集合中的重复元素。
class ArrayListTest
{
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("java02");
al.add("java03");
/*
在迭代循环中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;
}
}
--------------------------
集合框架(ArrayList练习2)
将自定义对象作为元素存到ArrayList集合中,并去除重复元素。
比如:存入人对象。同姓名同年龄,视为同一个人。为重复元素。
思路:
1,对人描述,将数据封装进人对象。
2,定义容器,将人存入。
3,取出。
List集合判断元素是否相同,依据的是元素的equals方法。
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
publci boolean equals(Object obj)
{
if(!obj instanceof Person)
return false;
Person p=(Person)obj;
Ststem.out.println(this.name+"......."+p.name);
return this.name.equals(p.name)&&this.age==p.age;
}
}
class ArrayListTest2
{
public static void sop(Object obj)
{
System.out.println(obj); }
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("lisi01",20);
al.add("lisi02",23);
al.add("lisi03",22);
al.add("lisi04",24);
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;
}
}
-------------------------------------
集合框架(HashSet)
Set:元素无序(存入和取出的顺序不一定一致),元素不可以重复。
HashSet:底层数据结构是哈希表。
Hash是如果保证元素唯一性?
是通过元素的两个方法,hashCode和equals来完成。
如果元素的HashCode值形同,才会判断equals是否为true。
如果元素的HashCode值不同,不会调用equals。
注意:对于判断元素是否存在,以及删除等操作,
依赖的方法是hashcode和equals方法。
TreeSet:
Set集合的功能和Collection是一致的。
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs=new HashSet();
sop(hs.add("java01"));
sop(hs.add("java01"));
hs.add("java02");
hs.add("java03");
hs.add("java04");
Iterator it=hs.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
------------------------------------------
集合框架(HashSet存储自定义对象-HashSet判断和删除的依据)
/*
往HashSet集合中存入自定义对象。
姓名和年龄相同为同一个人,重复元素。
*/
import java.util.*;
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.contains(new Person("a1",11));
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 String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
//System.out.println(this.name+"...hashCode");
return name.hashCode()+age;
}
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;
}
}