黑马程序员_java集合框架

来源：互联网发布：极客学院python视频编辑：程序博客网时间：2024/05/16 16:12

------- android培训、java培训、期待与您交流！ ----------

集合框架(体系概述)

·为什么出现集合类？
面向对象啊语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
·数组和集合类同时容器，有何不同？
数组虽然可以存储对象，但长度是固定的；集合长度是可变的。
数组中可以存储基本数据类型，集合只能存储对象。
·集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

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

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

------- android培训、java培训、期待与您交流！ ----------