黑马程序员_集合框架(一)

最新推荐文章于 2015-09-10 21:42:30 发布

精神病人精神好

最新推荐文章于 2015-09-10 21:42:30 发布

阅读量292

点赞数

本文链接：https://blog.csdn.net/kiss072403/article/details/21413051

版权

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

体系概述

每一个容器对数据的存储方式都不同。存储方式：数据结构

共性方法

Collection

1.add方法的参数类型是Object，以便接收任意类型对象

2.集合中存储的都是对象的地址(引用)

迭代器

集合取出元素的方式

取出方式定义在集合的内部，取出方式可以直接访问集合内部的元素

取出方式被定义成内部类

每一个容器的数据结构不同，所以取出的动作细节也不同，但都有共性内容：判断、取出。那么就可以将共性抽取：Iterator

这些内部类都符合一个规则：Iterator。获取集合取出对象，通过一个对外提供的方法：Iterator();

List集合共性方法 List集合具体对象的特点

Collection

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

|--ArrayList ：底层是数组数据结构特点：查询快，增删慢。线程不同步

|--LinkedList ：底层使用的是链表数据结构特点：增删快，查询慢

|--Vector ：底层是数组数据结构。线程同步。增删查询都慢，被ArrayList替代

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

|--HashSet ：底层数据结构是哈希表。

HashSet保证元素唯一性，通过元素的两个方法:hashCode和equals来完成

如果hashCode值相同，才会调用equals 。

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

|--TreeSet ：可以对Set集合中的元素进行排序。

底层数据结构是二叉树

保证元素唯一性的依据：compareTo方法ruturn 0;

List

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

增： add(index,element);

addAll(index,Collection);

删： remove(index);

改： set(index,element);

查： get(index);

subList(from,to);

listIterator();

List集合特有的迭代器：ListIterator,是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常（ConcurrentModificationException）,所以在迭代时只能用迭代器的方法操作元素，Iterator方法有限，只能判断、取出、删除。要做其他操作如添加、修改，需要使用其子接口：ListIterator。该接口只能通过List集合的ListIterator方法获取。

public class ListDemo {
	public static void method()
	{
		ArrayList a = new ArrayList();
		
		a.add("java01");
		a.add("java02");
		a.add("java03");
		sop("原集合："+a);
		
		//在指定位置添加元素
		a.add(1, "java09");
		sop("添加(1)后："+a);
		
		//删除指定位置的元素
		a.remove(2);
		sop("删除后(2)："+a);
		
		//修改元素
		a.set(2,"java08");
		sop("修改(2)后："+a);
		
		//通过角标获取元素
		sop("get(1):"+a.get(1));
		
		//获取所有元素
		for(int x=0; x<a.size(); x++)
		{
			System.out.println("a("+x+")="+a.get(x));
		}
		//迭代获取所有元素
		for(Iterator it = a.iterator();it.hasNext();)
		{
			sop("next:"+it.next());
		}
		//通过indexOf获取对象的位置
		sop("index="+a.indexOf("java08"));
		List sub = a.subList(1, 3);
		sop("subs="+sub);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) {
		method();
		
		//演示列表迭代器
		ArrayList a1 = new ArrayList();
		
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		sop(a1);
		
		ListIterator li = a1.listIterator();
		sop("hasPrevious():"+li.hasPrevious());	//判断迭代有没有前一个元素
		//在迭代过程中，添加或者删除元素
		while(li.hasNext())
		{
			Object obj = li.next();
			if(obj.equals("java02"))
			{
				li.add("java09");
				//li.set("java07");	//修改
			}
		}
		sop("hasNext():"+li.hasNext());		//判断迭代有没有后一个元素
		sop("hasPrevious():"+li.hasPrevious());	//判断迭代有没有前一个元素
		sop(a1);
	}
}

LinkedList

LinkedList特有方法

addFirst();

addLast();

getFirst();

getLast();

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

removeFirst();

removeLast();

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

在jdk1.6中出现了替代方法

offerFirst();

offerLast();

peekFirst();

peekLast();

获取元素，如果集合中没有元素，会返回NULL

pollFirst();

pollLast();

获取元素，如果集合中没有元素，会返回NULL

public class LinkedListDemo {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) {
		LinkedList link = new LinkedList();
		link.addLast("java01");
		link.addLast("java02");
		link.addLast("java03");
		link.addLast("java04");
		
		sop(link.getFirst());
		sop(link.getLast());
		sop("size="+link.size());

		while(!link.isEmpty())
		{
			sop(link.removeFirst());
		}
	}
}

LinkedList练习

/*
使用LinkedList模拟一个堆栈或队列数据结构
堆栈：先进后出
队列：先进先出
*/

class DuiLie
{
	private LinkedList link;
	DuiLie()
	{
		link = new LinkedList();
	}
	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}
	public Object myGet()
	{
		return link.removeLast();
	}
	public boolean isNull()
	{
		return link.isEmpty();
	}
}
public class LinkedListTest {
	
	public static void main(String[] args) {
		DuiLie dl = new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
		
		while(!dl.isNull())
		{
			System.out.println(dl.myGet());
		}
	}
}

堆栈只要把removeLast改成removeFirst

ArrayList练习

在迭代时，循环中next调用一次，就要用hasNext判断一次

/*
去除ArrayList集合中的重复元素
*/

public class ArrayListTest {
	
	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;
	}
	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("java01");
		al.add("java03");
		
		sop(al);
		al = singleElement(al);
		sop(al);
	}
}

List集合判断元素是否相同，依据的是元素的equals方法

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素
比如：存人对象，同性名同年龄，视为同一个人，为重复元素。
*/

class Person
{
	private String name;
	private int age;
	Person(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
		{
			return false;
		}
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
public class ArrayListTest2 {
	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;
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) {
		
		ArrayList al = new ArrayList();
		al.add(new Person("lisi01",30));
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi03",33));
		al.add(new Person("lisi04",35));
		al.add(new Person("lisi04",35));
		
		al = singleElement(al);
		
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}

HashSet

Set ：元素是无序的(存入取出顺序不一定一致)，元素不可以重复。

|--HashSet ：底层数据结构是哈希表。

HashSet保证元素唯一性，通过元素的两个方法:hashCode和equals来完成

如果hashCode值相同，才会调用equals 。

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

|--TreeSet ：可以对Set集合中的元素进行排序。

底层数据结构是二叉树

保证元素唯一性的依据：compareTo方法ruturn 0;

Set集合的功能和Collection是一致的。

public class HashSetDemo {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) {
		HashSet hs = new HashSet();
		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集合中存入自定义对象
姓名和年龄相同为同一个人，重复元素
*/
class Person
{
	private String name;
	private int age;
	Person(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public int hashCode()
	{
		return name.hashCode()+age*39;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
		{
			return false;
		}
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
public 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("a2",12));
		
		sop("a1:"+hs.contains(new Person("a1",11)));
		hs.remove(new Person("a3",13));
		
		Iterator it = hs.iterator();
		
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}

TreeSet

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

底层数据结构是二叉树

保证元素唯一性的依据：compareTo方法ruturn 0;

TreeSet排序第一种方式，让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。这种方式也称为元素的自然顺序，也叫默认顺序。

TreeSet排序第二种方式，当元素不具备比较性，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数

当两种排序都存在时，以比较器为主。

定以比较器：定义一个类，实现Comparator接口，覆盖compare方法

TreeSet存储自定义对象

TreeSet排序第一种方式，让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。这种方式也称为元素的自然顺序，也叫默认顺序。

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

/*
 往TreeSet集合中存储自定义对象学生，
 按学生年龄进行排序
*/

class Student implements Comparable //该接口强制让学生具备比较性
{
	private String name;
	private int age;
	
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
		{
			throw new RuntimeException("不是学生对象");
		}
		Student s = (Student)obj;
		if(this.age>s.age)
		{
			return 1;
		}
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
public class TreeSetDemo {

	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi08",19));
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

二叉树

TreeSet底层数据结构是二叉树。

实现Comparator方式排序

定以比较器：定义一个类，实现Comparator接口，覆盖compare方法

/*
按照姓名排序
*/

class Student implements Comparable //该接口强制让学生具备比较性
{
	private String name;
	private int age;
	
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
		{
			throw new RuntimeException("不是学生对象");
		}
		Student s = (Student)obj;
		if(this.age>s.age)
		{
			return 1;
		}
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class MyCompare implements Comparator
{
	public int compare(Object o1, Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}
public class TreeSetDemo2 {

	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new MyCompare());
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi08",19));
		ts.add(new Student("lisi007",21));
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}

TreeSet练习

/*
按字符串长度排序
*/
class StrLenComparator implements Comparator
{
	public int compare(Object o1, Object o2)
	{
		String s1 = (String)o1;
		String s2 = (String)o2;
		
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2);
		return num;
	}
}
public class TreeSetTest {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new StrLenComparator());
		ts.add("a");
		ts.add("bc");
		ts.add("def");
		ts.add("ghij");
		ts.add("klmno");
		ts.add("aaa");
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

泛型概述

泛型：JDK105版本以后出现的新特性，用于解决安全问题，是一个安全机制。

好处：

1.将运行时期出现的ClassCastException转移到了编译时期，方便与程序员解决问题，让运行时期问题减少。

2.避免了强制转换的麻烦

public class GenericDemo {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abcd02");
		al.add("ab03");
		
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s+":"+s.length());
		}
	}
}

泛型使用

格式：通过<>来定义要操作的引用数据类型

使用：通常在集合框架中很常见。

<>是用来接收类型的

当时用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

class LenComparator implements Comparator<String>
{
	public int compare(String o1, String o2)
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)
			return o1.compareTo(o2);
		return num;
	}
}
public class GenericDemo2 {
	public static void main(String[] args) {
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());
		ts.add("a");
		ts.add("bc");
		ts.add("def");
		ts.add("ghij");
		ts.add("klmno");
		ts.add("aaa");
		
		Iterator<String> it = ts.iterator();
		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s);
		}
	}
}

泛型类

当类中要操作的引用数据类型不确定时，定义泛型来完成扩展

class Worker
{
	
}
class Student
{
	
}
class Utils<AA>	//泛型类
{
	private AA a;
	public void setObject(AA a)
	{
		this.a = a;
	}
	public AA getObject()
	{
		return a;
	}
}
public class GenericDemo3 {

	public static void main(String[] args) {
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject();
	}
}

泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有方法要操作的类型就固定了。

为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

class Demo<T>	//泛型定义在类上
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
	public void print(T t)
	{
		System.out.println("print:"+t);
	}
}
class Demo2	//泛型定义在方法上
{
	public <T> void show2(T t)
	{
		System.out.println("show2:"+t);
	}
	public <Q> void print(Q q)
	{
		System.out.println("print2:"+q);
	}
}
public class GenericDemo4 {
	public static void main(String[] args) {
		Demo<Integer> d = new Demo<Integer>();
		d.show(3);
		d.print(6);
		
		Demo2 d2 = new Demo2();
		d2.show2("java");
		d2.print(5);
	}
}

泛型接口

interface Inter<T>
{
	void show(T t);
}
class InterImpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("show:"+t);
	}
}
class InterImpl2<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show2:"+t);
	}
}
public class GenericDemo5 {

	public static void main(String[] args) {
		InterImpl i = new InterImpl();
		i.show("java");
		InterImpl2<Integer> i2 = new InterImpl2<Integer>();
		i2.show(8);
	}
}

泛型限定

？：通配符也可以理解为占位符

泛型的限定：

？ extends E ：可以接收E类型或者E的子类型（上限）

？ super E ：可以接收E类型或者E的父类型（下限）

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student (String name)
	{
		super(name);
	}
}
public class GenericDemo6 {
	public static void printColl(ArrayList<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
	public static void main(String[] args) {

		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc01"));
		al.add(new Person("abc02"));
		al.add(new Person("abc03"));
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("def01"));
		al2.add(new Student("def02"));
		al2.add(new Student("def02"));
		
		printColl(al2);
	}
}

泛型限定2

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public String toString()
	{
		return "person:"+name;
	}
}
class Student extends Person
{
	Student (String name)
	{
		super(name);
	}
}
class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}
class Comp implements Comparator<Person>
{
	public int compare(Person p1, Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}
public class GenericDemo7 {

	public static void main(String[] args) {
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Student("abc03"));
		ts.add(new Student("abc02"));
		ts.add(new Student("abc04"));
		ts.add(new Student("abc01"));
		
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
		
		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
		ts1.add(new Worker("abc--03"));
		ts1.add(new Worker("abc--02"));
		ts1.add(new Worker("abc--04"));
		ts1.add(new Worker("abc--01"));
		
		Iterator<Worker> it1 = ts1.iterator();
		while(it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
	}
}

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

详细请查看：http://edu.csdn.net