疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java基础集合中的体系结构分析


 

 
 
Collection |--List:元素之间有序,且可以重复。
|--ArrayList: 使用数组存储的数据结构。增删慢,查询快。注意:此实现不是同步的
|--LinkedList: 使用链表存储的数据结构。增删快,查询慢。
|--Vector: 使用数组存储的数据结构。是同步到,访问速度较慢,被ArrayList所替代。
|--Set:元素之间无序,不可以重复。
List集合提供的方法
add(index,element)//在指定位置插入指定元素
addAll(index,Collection)//指定位置插入集合
remove(int index) 
移除列表中指定位置的元素(可选操作)。
set(int index, E element) 
用指定元素替换列表中指定位置的元素(可选操作)。
iterator() 查找元素
listIterator() 返回此列表元素的列表迭代器(按适当顺序)。
subList(int fromIndex, int toIndex) 
返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。
 
 
List集合特有的迭代器:ListIterator迭代器。
---listIterator是Iterator的子类接口。可以允许程序员按照任意方向遍历数据、修改数据、添加数据。
---Iterator迭代器只能够向下遍历数据,删除数据。如果要修改数据会出现ConcurrentModificationException异常
ListIterator提供的方法:
-->hasPrevious() 是否有前一个元素
-->previous()获取前一个元素
-->void remove() 
从列表中移除由 next 或 previous 返回的最后一个元素(可选操作)。 
-->void set(E e) 
用指定元素替换 next 或 previous 返回的最后一个元素(可选操作)。 
-->add()添加元素
 
 
import java.util.*;
public class ListDemo{
public static void main(String []args){
//List list = method_Add();
//method_it(list);
//sop(list);
method_ArrayList();
}
public static void method_ArrayList(){
ArrayList al = new ArrayList();
sop(al.size());
}
public static List method_Add(){
List list = new ArrayList();
list.add("java1--->name");
list.add("java2--->name");
list.add("java3--->name");
list.add(2,"java4--->name");  //在制定位置插入
return list;
}
public static void method_it(List list){
//通过iteraror遍历元素
ListIterator li = list.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("java3--->name"))
li.add("i love xy");
sop(obj);
}
while(li.hasPrevious()){
Object obj1 = li.previous();
sop("逆序--"+obj1);
}
/**此处会抛出ConcurrentModificationException异常
Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("java3--->name")){
list.add("i love xuYan");
}
sop(obj);
}**/
}
public static void sop(Object obj){
System.out.println(obj);
}
}
ArrayList和Vector的异同:
1、相同点:两者都是使用数组存储的数据结构。
2、不同点:
2.1 ArrayList是1.1版本以后出现的,其执行效率高于Vector。
2.2 Vector是线程同步的,ArrayList是线程不同步的。
2.3 ArrayList和Vector默认初始容量是10,扩充容量时,ArrayList以50%扩充,而Vector以100%扩充。
2.4 Vector支持枚举类型。ArrayList不支持枚举。
枚举(Enumeration)其实和迭代器(Iterator)类似。
不过在1.1版本以后,Iterator中的方法名比较短,代替了枚举的方法。
 
 
import java.util.*;
public class VectorDemo{
public static void main(String args[]){
Vector v = new Vector();
v.add("hello");
v.add("world");
v.add("hi");
v.add("java");
Enumeration en = v.elements();  //获取枚举类型的数据
while(en.hasMoreElements()){
System.out.println("遍历枚举类型的数据:"en.nextElement());
}
}
}
LinkedList提供的方法:
JDK1.6以后提供的方法
offerFirst(E e) 
在此列表的开头插入指定的元素。 
offerLast(E e) 
在此列表末尾插入指定的元素。 
pollFirst() 
获取并移除此列表的第一个元素;如果此列表为空,则返回 null。 
pollLast() 
获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。 
 
set(int index, E element) 
将此列表中指定位置的元素替换为指定的元素。
peekFirst() 
获取但不移除此列表的第一个元素;如果此列表为空,则返回 null。 
peekLast() 
获取但不移除此列表的最后一个元素;如果此列表为空,则返回 null。 
import java.util.*;
public class LinkedListDemo{
public static void main(String args[]){
LinkedList ll = new LinkedList();
ll.offerFirst("java1");
ll.offerFirst("java2");
ll.offerFirst("java3");
ll.offerFirst("java4");
sop(ll);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
练习:在LinkedList的基础上封装一个自己使用的堆栈和队列的数据结构
堆栈特征--->先进后出
队列特征--->先进先出
 
import java.util.*;
class DuiLie{
LinkedList link;
public DuiLie(){
link = new LinkedList();
}
/*
添加队列中的数据。
*/
public void myAdd(Object obj){
link.offerFirst(obj);
}
/*
获取队列中的数据。以link链表中的最后一个数据取出
*/
public Object myGet(){
return link.pollLast();
}
public boolean isNull(){
return link.isEmpty();
}
}
class Zhan{
LinkedList link;
public Zhan(){
link = new LinkedList();
}
/*
添加队列中的数据。
*/
public void myAdd(Object obj){
link.offerFirst(obj);
}
/*
获取队列中的数据。以link链表中的最后一个数据取出
*/
public Object myGet(){
return link.pollFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
public class LinkedListDemo{
public static void main(String args[]){
Zhan dl = new Zhan();
dl.myAdd("java1");
dl.myAdd("java2");
dl.myAdd("java3");
dl.myAdd("java4");
while(!dl.isNull()){
sop(dl.myGet());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
练习:去除ArrayList中的相同对象元素。即:姓名和年龄相同的
步骤:
1、构造Person类,定义姓名、年龄两个属性,重写equals方法。
2、将Person对象存储到ArrayList集合中。
3、将对象一个个的取出。
4、定义一个新的集合,将就集合中的数据放入新集合,在此之前先判断新集合中是否存在该数据。
 
 
import java.util.*;
class Person{
private String name ;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public int getAge(){
return this.age;
}
public String getName(){
return this.name;
}
//因为要比较的是Person类中的name和age值,所以重写Object类的equals方法,
public boolean equals(Object obj){
//如果传入的对象不是Person类,直接返回false
if(!(obj instanceof Person))
return false;
//否则强转成Person类
Person p = (Person)obj;  
//返回name和age的比较值。
return this.name.equals(p.getName()) && this.age == p.getAge();
}
}
public class ArrayListDemo{
public static void main(String args[]){
ArrayList al = new ArrayList();
//Person p = new Person();
al.add(new Person("lzl",18));
al.add(new Person("lzl1",18));
al.add(new Person("lzl2",18));
al.add(new Person("lzl3",18));
al.add(new Person("lzl",18));
al = sigleElements(al);
Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
sop(p.getName()+"---"+p.getAge());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
/*
去除相同的元素
*/
public static ArrayList sigleElements(ArrayList al){
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while((it.hasNext())){
Object obj = it.next();
//如果新链表中不存在P对象的元素,则添加。
if(!newAl.contains(obj)){
sop("---");
newAl.add(obj);
}
}
return newAl;
}
}