面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就是对对象进行存储,集合就是存储对象最常用的方式。
数组和集合类的不同:
两者都是容器,数组虽然也可以存储对象,但长度是固定的;集合长度是可变的,数组中可以存储基本数据类型,集合只能存储对象。
集合类的特点:
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
为什么会出现很多容器?每个容器对数据的存储方式都有不同,该存储方式称为数据结构。
Collection中的方法:
add方法的参数是Object,以便于接收任意类型的对象。
集合中存储的都是对象的引用(地址)
什么是迭代器?
就是集合中取出元素的方法。
java中集合类的关系图
集合中添加元素
/*
** Collection add()方法。
*/
import java.util.*;
class CollectionDemo{
public static void main(String[] args){
ArrayList al=new ArrayList();
//向集合中添加元素。
al.add("java 001");
al.add("java 002");
al.add("java 003");
al.add("java 004");
al.add("java 005");
//it对象在使用完毕即销毁。
for(Iterator it=al.iterator();it.hasNext();){
sop(it.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
集合中数据操作
/*
** Collection 方法。
** List:容器中的元素是有序的,可以重复,元素有索引。
** Set:容器中元素是无序的,不可以重复。
** List特有的方法:凡是可以操作角标的方法都是该体系特有的方法。
** 增加:add(index,element);
addAll(index,collection);
** 删除:remove(index);
** 修改:set(index,element);
** 查找:get(index);
subList(from,to);
listIterator();
** 获取集合长度:size();
** List 集合特有的迭代器:ListIterator。其是Iterator的子接口。
** 在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生并发异常,即:迭代方法和集合对象方法同时操作集合中的元素。
** 在迭代时,只能通过迭代的方法操作元素,但操作有限,需用ListIterator子接口方法操作元素。
** 该接口只能通过List的listIterator方法获取。
*/
import java.util.*;
class ListDemo{
public static void main(String[] args){
ArrayList al=new ArrayList();
al.add("java 001");
al.add("java 002");
al.add("java 003");
al.add("java 004");
al.add("java 005");
//it对象在使用完毕即销毁。
for(Iterator it=al.iterator();it.hasNext();){
sop(it.next());
}
sop("删除指定位置(角标3)的元素");
al.remove(3);
sop(al);
sop("修改指定位置(角标1)的元素");
al.set(1,"java 007");
sop(al);
sop("查找指定位置(角标1)的元素");
sop(al.get(1));
sop("获取集合中的所有元素");
sop(al.subList(0,al.size()));
sop("获取集合中的所有元素,方法二:");
Iterator it=al.iterator();
while(it.hasNext()){
sop(it.next());
}
//获得指定对象(java 007)的位置:
sop(al.indexOf("java 007"));
//返回列表中最后一次出现指定元素(java 007)的位置。
sop(al.lastIndexOf("java 007"));
sop("通过ListIterator 子接口操作集合中的元素");
ListIterator li=al.listIterator();
while(li.hasNext()){
Object obj =li.next();
if(obj.equals("java 007")){
li.remove(); //此处已经删除了,为什么还能打印出来。
//此处删除的是集合元素的引用,在此之前已将该引用值赋给了obj,下方打印的是obj的值。
li.add("java 009");
//li.set("java 0010");
}
sop(obj);
}
sop("删除jva 007的元素。增加java 009的元素");
sop(al);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
模拟队列的先进先出和堆栈的先进后出特性
// 模拟队列和堆栈的先进先出和先进后出的过程。
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie(){
link=new LinkedList();
}
public void myAdd(Object obj){
link.addFirst(obj);
}
//输出最下层的元素。
//removeLast(),删除并返回此列表中的第一个元素。
//若使用getLast(),则只能得到列表中的最后一个元素。必须删除,后续的才能下降为最后一个元素
public Object myGet(){
return link.removeLast();
}
public boolean isNull(){
return link.isEmpty();
}
}
class DuiZhan
{
private LinkedList dz;
DuiZhan(){
dz=new LinkedList();
}
public void myAdd(Object obj){
//率先加入的垫底。
dz.addFirst(obj);
}
public Object myGet(){
//输出最上层的元素。
//removeFirst(),删除并返回此列表中的第一个元素。
//若使用getFirst(),则只能得到列表中的第一个元素。必须删除,后续的才能上升为第一个元素。
return dz.removeFirst();
}
public boolean isNull(){
return dz.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl=new DuiLie();
DuiZhan dz=new DuiZhan();
//增加队列元素。
dl.myAdd("java 001");
dl.myAdd("java 002");
dl.myAdd("java 003");
dl.myAdd("java 004");
sop("队列的先进先出特性");
while(!dl.isNull()){
sop(dl.myGet());
}
//增加堆栈元素。
dz.myAdd("DuiZhan 001");
dz.myAdd("DuiZhan 002");
dz.myAdd("DuiZhan 003");
dz.myAdd("DuiZhan 004");
sop("堆栈的先进后出特性");
while(!dz.isNull()){
sop(dz.myGet());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
HashSet类型
/*
Set:元素是无序的(存入和取出的数序不一定一致),元素不可以重复。
|---HashSet:底层数据结构是哈希表。
HashSet是如何保证元素的唯一性?
通过元素的两个方法:hashCode和equals来完成。
如果元素的hashCode值相同,才会判断equals是否为true。
如果元素的hashCode值不同,不会调用equals.
注意,对于判断元素是否存在(contains),删除(remove)等,依赖的方法是hashCode和equals.
*/
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
//重写字符串的哈希值。构建姓名+年龄的哈希值。
public int hashCode(){
return name.hashCode()+age;
}
//重写equals方法。
public boolean equals(Object obj){
//首先判断是否为Person类型,如果不是,直接pass
if(!(obj instanceof Person)){
return false;
}
//强制类型转换。先转换为Person类型。
Person p=(Person)obj;
//姓名年龄均相同为同一个人。
return this.name.equals(p.name)&&(this.age==p.age);
}
}
class HashSetDemo
{
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add(new Person("hash 001",1));
hs.add(new Person("hash 002",2));
hs.add(new Person("hash 003",3));
hs.add(new Person("hash 004",4));
hs.add(new Person("hash 005",5));
hs.add(new Person("hash 004",4));
//使用iterator方法构建迭代器。
Iterator it=hs.iterator();
while(it.hasNext()){
Person p=(Person)it.next();
sop(p.getName()+"..."+p.getAge());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}