黑马程序员_集合

WoW_1998

于 2014-08-13 12:20:24 发布

阅读量282

点赞数

分类专栏： java 文章标签：集合

本文链接：https://blog.csdn.net/WoW_1998/article/details/38535041

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

集合框架：

|--Collection

|--List

|--ArrayList

|--LinkedList

|--Vector

|--Set

|--HashSet

|--TreeSet

这些容器对数据的存储方式的不同是他们之间最本质的区别

这个存储方式称之为：数据结构

罗列了集合框架后不得要提一下集合的搭档：迭代器

迭代器

格式：

Iterator ite =集合对象.iterator()

方式一：

Iterator ite = 集合对象.iterator();

while(ite.hasNext)

{

       sop(ite.next);

}

方式二：

for(Iterator ite = 集合对象.iterator(); ite.hasNext; )

{

       sop(ite.next);

}

方式二的好处：循环结束后释放Iterator

Collection

List：元素是有序的，元素可以重复，因为该集合体系有索引

Set：元素是无序的，元素不可以重复

List

特有方法：（凡是可以操作角标的方法都是该体系特有的方法）

以下列举的是常见的

增

add(index, element);

addAll(index, Collection);

删

remove(index);

改

set(index, element);

查

get(index);

subList(from, to);

说起方法，这里详细介绍一个listIterator()方法：

ListIterator

List集合特有的迭代器：ListIterator是Iterator的子接口

之所以在有Iterator的情况下又编写一个子类ListIterator是因为功能的扩展需要：

当我们用集合操作数据的同时又用迭代器操作集合中的数据，

容易引发并发修改异常，就像两只脚同时踹中一个足球一样，

所以同一个数据只能用一种方式来操作。

这样就有很大的限制

Iterator方法是有限的

只能对元素进行判断、取出、删除的操作

所以

如果想要其他的操作如添加、修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法来获取

格式：

ListIterator li = List集合对象.listIterator();

List集合具体对象的特点：

ArrayList：

底层的数据结构使用的是数组结构

特点：

查询速度快（按脚标查询当然快）

但是增删稍慢（插入一个元素，后面的元素的脚标都要往后挪，就像往一排麻将里插进一张牌，而且还是要一张一张挪的那种）

线程不同步

每次50%延长

LinkedList：

底层使用的是链表数据结构

特点：

增删速度快

查询速度稍慢

Vector：

底层是数组数据结构

特点：

线程同步

每次100%延长

（被ArrayList替换，开发时大多数都用）

List集合具体对象的应用：

Vector

枚举就是Vector特有的取出方式，发现枚举和迭代器很像，其实枚举和迭代是一样的

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

class VectorDemo

{

       	public static void main(String[] args)

	{

       		Vector v = new Vector();

       		v.add("java01");

       		v.add("java02");

       		Enumeration en = v.elments();

       		while(en.hasMoreElements())

		{

       			System.out.println(en.nextElements());

		}
	
	}

}

LinkList

LinkList特有方法JDK1.6以前：

addFirst();

addLast();

getFirst();

getLast();

获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException

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

offerFirst();

offerLast();

peekFirst();

peekLast();

获取元素，但不删除元素，如果集合中没有元素，会返回null

pollFirst();

pollLast();

获取元素，但是元素被删除，如果集合中没有元素，会返回null

模拟队列：先进先出

class DuiLie

{

       	private LinkedList link;

       	DuiLie()

	{

       		link = new LinkedList();

	}

	public void set(Object obj)

	{

       		link.addFirst(obj);

	}

	public Object get()

	{

       		return link.removeLast();

	}

	public boolean isNull()

	{

       		return link.isEmpty();

	}

}

class Demo

{

       	public static void main(String[] args)

	{

       		DuiLie dl = new DuiLie();

       		dl.set("java01");

       		dl.set("java02");

       		dl.set("java03");

       

       		while(!dl.isNull())

		{

       			System.out.println(dl.get());

		}

	}

}

ArrayList

去除ArrayList中重复的元素

class Demo

{

       	public static void main(String[] args)

	{

       

	}

	public static ArrayList singleArrayList(ArrayList list)

	{

       		ArrayList newAl = new ArrayList();

       		ListIterator ite = list.listIterator();

       		while(ite.hasNext())

		{

       			Object obj = ite.next();

       			if(!newAl.contains(obj))

              			ite.add(obj);

		}

		return newAl;

	}

}

因为contains方法底层靠的是equals为准的

所以再写一个类，并且覆盖equals方法，自定义规则

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 boolean equals(Object obj)

	{

       		if(obj intanceof Person)

              		return false;

       		Person p = (Person)obj;

       		return p.name.equals(this.name) && p.age == this.age;

	}

}

class Demo

{

       	public static void main(String[] args)

	{

       

	}

	public static ArrayList singleArrayList(ArrayList list)

	{

       		ArrayList newAl = new ArrayList();

       		ListIterator ite = list.listIterator();

       		while(ite.hasNext())

		{

       			Object obj = ite.next();

       			if(!newAl.contains(obj))

              			ite.add(obj);

		}

		return newAl;

	}

}

Set

元素是无序的（存入和取出的循序不一定一致），元素不可以重复

HashSet：

底层数据结构是哈希表（哈希表的特点：唯一性）

HashSet是如何保证元素唯一性的呢？

是通过元素的两个方法：hashCode()和equals()来完成的

如果元素的HashCode值相同，才会判断equals是否为true

如果元素的HashCode值不同，才会调用equals

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的

hashCode和equlas方法

先比hashCode()再比equals()

class Student

{

       	private String name;

       	private int age;

       	Student(String name,int age)

	{

       		this.name = name;

       		this.age = age;

	}

	public Stirng getName()

	{

       		return this.name;

	}

	public int getAge()

	{

       		return this.age;

	}

	public int hashCode()

	{

       		return this.name .hashCode()+ this.age*37;

	}

	public boolean equals(Object obj)

	{

       		if(!(obj instanceof Student))

              		throw new ClassCastException(“类型不匹配”);

       		Student stu = (Student)obj;

       		return this.name.equals(stu.name) && this.age == stu.age;

	}

	public void toString()

	{

       		System.out.println(“[”+this.name+”,”+this.age+”]”);

	}

}

TreaSet

底层数据结构是二叉树

可以对Set集合中的元素进行排序

排序时，当主要条件相同时，一定要判断一下次要条件

底层数据结构是二叉树

保证元素唯一性的依据

compareTo方法return 0，则该对象不存储进Set集合

TreeSet排序的第一种方式：

让元素自身具备比较性

元素需要实现Comparable接口，覆盖compareTo方法。

这种方式也称为元素的自然顺序，或者叫做默认顺序

第一种方式：
class Student implements Comparable
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj intanceof Student))
			throw new RuntimeException(“不是学生对象”);
		Student s = (Student)obj;
		if(this.age > s.age)
			return 1;
		if(this.age == s.age)
		{
			return this.name.comparaTo(s.age);
		}
		return -1;
	}
}

TreeSet排序的第二种方式：

当元素自身不具备比较性时，或者具备的比较性不是所需要的

这时就需要让集合自身具备比较性

在集合初始化时，就有了比较方式

第二种方式：
实现Comparator方式排序

class MyCmpara implements Comparator
{
	public int compare(Object o1, Object o2)
	{
		Student stu1 = null;
		Student stu2 = null;
		if((o1 instanceof Student) && (o2 instanceof Student))
		{
			stu1 = (Student)o1;
			stu2 = (Student)o2;
		}
		int num = stu1.getName().compareTo(stu2.getName());
		if(num == 0)
			return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
		return num;
	}
}

第一种方式是属于默认元素排序，第二种方式与第一种方式同时使用时，第二种覆盖第一种

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com