【黑马程序员】java中----------Collection集合框架

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

一、集合容器描述

1. 集合是容器，主要是用于存储对象。容器有很多种，主要是因为对数据的存储结构不同而不同

2. 数据多了可以用数字存储，对象多了可以用集合存储，数组长度固定，而集合是可变长度的

3. 集合中存储的是对象的引用（就是内存地址）

4. collection是顶层接口，其中有两大实现类List集合和Set集合

二、集合和数组的区别

数组：同一个数组只能存储同一种数据，一但声明就不可以改变，可以存储数组对象也可以存储基本数据类型

多数情况下都是用数组存储基本数据

集合：只可以存储对象，长度是可以改变的，类型可以多样

三、集合的特点

1. 只用于存储对象，长度可变，可以存储不同类型的对象

2. 集合是一个接口，是众多集合的共性内容

四、数据结构

每种容器对数据 的存储方式是不一样的，所以出现不同容器的数据结构不相同。

五、集合框架体系图

六、集合中的共性方法

1.增加

boolean  add（objectobj）添加元素

boolean addAll（collection<? extends  E> c）将指定collection集合中的所有元素添加到此集合中

2.删除

void  clear()移除集合中所有的元素

boolean  remove(object   obj)  为真的条件下将元素移除

boolean   removeAll(collection<?> c)

3.判断

boolean   contains(object  o)判断指定元素是否存在

booleanisEmpty(); 判断集合是否为空

4.获取

int  size（）；获取集合长度

booleanretainAll(collection <?>  c); 获取两个集合的交集

5.对元素的取出方式：迭代器

Iterator<E>  iterator();返回此集合中的迭代器

booleanhasNext(); 判断是否有下一个元素

Enext(); 返回迭代的下一个元素

void  remove（）；异常迭代器返回的元素

6.集合转换成数组

toArray()；

List接口

一、List接口继承Collection接口，List接口中最常用的3个已实现的集合类：ArrayList、LinkedList、Vector

二、ArrayList、LinkedList、Vector集合的区别

ArrayList集合：底层是数据结构是数组结构，查询速度快，增删慢，线程不同步

LinkedList集合：底层数据结构是链表数据结构，增加删除快，查询比较慢，线程不同步

Vector集合：底层数据结构是数组结构，增删改查都比较慢，被ArrayList所替代。jdk1.2版本出现

三、List接口提供的特有共性方法

1. 增加

booleanadd（int index，E element）；在指定位置增加元素

booleanaddAll(collection <?  extendsE> c);将指定集合中的元素添加进集合的末尾处

2. 删除

Eremove（int index）；删除指定位置上的元素

void  removeRage（int   fromIndex，int toIndex）删除指定开始索引到指定位置的元素

3. 修改

E   set(int   index, E   element);替换指定位置上的元素

4. 获取

E  get(int  index);  获取指定位置上的元素

intindexOf(object element);返回指定元素的角标

intlastIndexOf(object     element);返回指定元素最后一次出现的角标

List<E>subList(int  fromIndex, int  toIndex);返回指定开始位置到指定结束位置上的元素的集合

注意事项：

1. listIterators是List集合特有的迭代器，是Iterator子接口。

2. 操作集合中的元素，要注意避免发生并发修改异常（ConcurrentModficationException）

所以操作集合中的元素，需要用到迭代器Iterator，但是Iterator中的方法只有3个，

不满足需求的情况下使用：listIterator迭代器（包括增删改查方法）

3. 要注意，迭代器的使用时，hasNext()判断一次，只能调用一次next（）；

4. List中提供了contains（objecto）方法，判断元素是否包含,依据的是equals()方法

四、Vector集合

Vector集合中特有的取出方式，即为枚举。

1. 枚举与Iterator都是取出元素的方式，为了简化书写，Iterator代替了枚举

Enumeration<?>elements();返回此向量组件的枚举

练习代码：

class VectorDemo
{
	public static void main(String[] args) 
	{
		Vector v = new Vector();

		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");

		Enumeration en = v.elements();

		while(en.hasMoreElements())
		{
			System.out.println(en.nextElement());
		}
	}
}

五、LinkedList集合

jdk1.2中的方法

1. 增加：

addFirst(E   e);将指定元素添加到集合的第一个位置

addLast(Ee); 将指定元素添加到集合的末尾处

2. 获取：

EgetFirst(); 返回集合中第一个元素，不删除元素

EgetLast(); 返回集合中最后一个元素，不删除元素

如果元素不存在，则发生没有这个元素异常：NoSuchElementsException
3. 删除

EremoveFirst();移除集合中第一个元素，元素被删除

EremoveLast(); 移除集合中最后一个元素，元素被删除

jdk1.6版本出现的替代方法；

增加；

offerFirst(E e);将指定元素添加进集合中的开头

offerLast(E e); 将指定元添加进集合的末尾处

获取：

peakFirst(); 获取集合的第一个元素，不删除元素

peakLast（）； 获取集合的最后一个元素，不删除元素

 删除：

pollFirst();移除集合中第一个元素，并且返回

pollLast（）；返回最后一个元素，并且删除元素

代码练习：

/*用LinkedList模拟堆栈或者队列结构
堆栈：先进先出
队列：先进后出
*/

//将我们要的功能封装成一个类，在开发中，经常这样做
import java.util.*;
class duiLie{
	private LinkedList link;
	duiLie(){
		link =new LinkedList();
	}
	public void myAdd(Object obj){
		link.addFirst(obj);//先进
		//link.addLast(obj);
	}
	public Object myGet(){
		return link.removeFirst();//后出
		//return link.removeLast();//先出
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class LinkedListTest{
	public static void main(String[] args){
		duiLie dl=new duiLie();
			dl.myAdd("云1");
			dl.myAdd("云2");
			dl.myAdd("云3");
			dl.myAdd("云4");
		while(!dl.isNull()){
		System.out.println(dl.myGet());
		}
		
	}
}

set集合

一、特点

集合中不可以存储重复元素，，

元素是无序的（存入和取出的顺序不一致），

线程不同步

二、HashSet集合

数据结构是哈希表结构，元素不可重复，线程同步，唯一的取出元素的方式

Iterator迭代器，

1. 保证元素的唯一性的依据：

通过元素的两个方法：hashCode()和equals（object    o）方法

如果元素的hashCode()值相同，才会去判断equals（）方法是否为真；

如果hashCode ()值相同，就不会去判断equals（）方法，间接的提供了比较效率

注意：对于判断元素是否存在，添加和删除操作，都是依赖元素的hashCode()和equals（0方法

练习代码：

/*Set:元素是无序的（存入和取出的顺序是不一致的），元素不可以重复
		hashSet集合，是哈希表数据结构
		它保证元素唯一是通过两个方法，hashCode方法和equals方法
		如果元素的hashCode值相同，才会调用equals方法进行比较
		
		*/
import java.util.*;
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("java1"));//add方法的返回值是boolean:true
		//sop(hs.add("java1"));//false,,hashCode值相同，所以
		
		hs.add("java3");
		hs.add("java2");
		hs.add("java2");
		
	
		hs.add(new Person("zhangsan1",20));
		hs.add(new Person("zhangsan2",26));
		hs.add(new Person("zhangsan3",25));
		hs.add(new Person("zhangsan3",25));
		Iterator it=hs.iterator();
		while(it.hasNext()){
			Object obj=it.next();
			if(obj instanceof Person){
				Person p=(Person)obj;
				sop(p.getName()+"====="+p.getAge());
				}
			else {
				
				sop(obj);
				}
		}
	}
}

class Person{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int hashCode(){
	
		System.out.println(this.name+"-----hashCode");        //查看对象自动调用此方法
		return  this.name.hashCode()+age*8;//为了避免不同的两个对象的哈希值相同，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;
		
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	
}

TreeSet集合

特点：

此集合数据结构是二叉树结构，

元素不可以重复

此集合会按照元素的自然顺序进行排序

线程不同步

如果存入的集合不具备比较性，会发生异常：ClassCastException

保证元素唯一性的依据：

根据元素的调用compareTo()方法的返回值（正、负、零）判断元素是否为同一个元素；

返回值为：0，视为元素相同，不存储

元素不具备比较性怎么办：

第一种方式：让元素实现Comparable接口，覆盖compareTo()方法。让元素具备比较性

练习代码：

/*TreeSet集合：元素具备自然排序；如果元素不具备比较性需要让元素具备比较性
实现接口：Comparable;  复写compareto()方法,就这一个方法

学生按照age排序，如果age相同，
则判断次要条件：this.name.compareTo(s.name);name是字符串，compareTo()方法
*/

import java.util.*;
	
class TreeSetTest{
	public static void main(String[] args){
		
		TreeSet ts=new TreeSet();
		ts.add(new Student("云01",22));
		
		ts.add(new Student("云07",20));
		ts.add(new Student("云08",20));
		
		ts.add(new Student("云04",40));
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			Student stu=(Student)it.next();	
			System.out.println(stu.getName()+"---"+stu.getAge());
			//System.out.println(it.next());
		}
	
	
	}
}
//让学生具备比较性，实现Comoarable接口
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 name;
	}
	public int getAge(){
		return age;
	}
	//覆盖compareTo()方法
	public int compareTo(Object obj){
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生");
		Student s=(Student)obj;

		System.out.println(this.name+"----compareto---"+s.name);
		if(this.age>s.age)
		    return 1;
		if(this.age==s.age)
		     return this.name.compareTo(s.name);
		return -1;
	}
}

第二种方式：定义比较器

如果让元素自身具备比较性不是我们所需要的，这是可以让集合自身具备比较性；

自定义一个比较器，并且实现Comparator接口，并且覆盖compare（object   o）方法

根据：此方法的返回值（零、正数、负数）来判断存入的元素是否相同

注意事项：两种排序方式都存在时，以比较器为主，排序时，主要条件相同时，比较次要条件

练习代码：

/*在TreeSet集合中：如果元素的排序方式不是所需要的，（即使是实现的comparable）

那么就需要自定义：比较器，实现comparator接口；自定义比较器，让集合自身具备比较性；
并通过treeset集合的构造函数传进去

两种排序方式都在时，以比较器为主。

*/
import java.util.*;
	
class TreeSetTest1{
	public static void main(String[] args){
		TreeSet ts=new TreeSet(new MyComparator());
		
		ts.add(new Student("huchangsheng01",23));
		ts.add(new Student("huchangsheng03",25));
		
		ts.add(new Student("huchangsheng01",40));
		ts.add(new Student("huchangsheng05",27));
		ts.add(new Student("huchangsheng07",29));
		 
		 
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			Student stu=(Student)it.next();
			System.out.println(stu.getName()+".........."+stu.getAge());
		}
	
	
	}
}
//自定义比较器，让集合自身具备比较性
class MyComparator 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;
	}
}
//让学生具备比较性，实现Comoarable接口
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 name;
	}
	public int getAge(){
		return age;
	}
	//覆盖此方法
	public int compareTo(Object obj){
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生");
		Student s=(Student)obj;

		//System.out.println(this.name+"----compareto---"+s.name);//查看TreeSet底层自动调用此方法
		if(this.age>s.age)
		    return 1;
		if(this.age==s.age)
		     return this.name.compareTo(s.name);
		return -1;
	}
}

练习代码：自定义比较器，一length长度排序

	/*	
		以lenhth()来排序,用的是集合比较器
		*/

		
		
import java.util.*;
class TreeSetTest2{
	public static void main(String[] args){
		TreeSet ts=new TreeSet(new StringLengthComparator());    //参数可以改写匿名类部类
		ts.add("云ad");
		ts.add("云badc");
		ts.add("云ce");
		ts.add("云abc");
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			//Student stu=(Student)it.next();	
			//System.out.println(stu.getName()+"---"+stu.getAge());
			System.out.println(it.next());
		}
	
	
	}
}

class StringLengthComparator 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){				//如果有相同length()需要判断
			return s1.compareTo(s2);
		}
		return num;
			
		/*if(s1.length()>s2.length());
			return 1;
		if(s1.length()<s2.length());
			return -1;
		return 0;
		*/
	}
}

练习代码：

/*
	泛型在比较器当中的应用
	泛型的出现，用于解决安全问题，也避免了强转麻烦
*/
 
 
import java.util.*;

class TreeSetTest3{
	public static void main(String[] args){
		TreeSet<String> ts=new TreeSet<String>(new StringLengthComparator());   
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahahaha");
		//通过TreeSet集合获取迭代器
		Iterator<String> it=ts.iterator();
		while(it.hasNext())
		{
			String s =it.next();	
			System.out.println(s);
		}
	
	
	}
}
class StringLengthComparator implements Comparator<String>{
	public int compare(String o1,String o2){

		//String s1=(String)o1;                 //泛型不用向下强转
		//String s2=(String)o2;
		int num=new Integer(o1.length()).compareTo (new Integer(o2.length()));
		if (num==0){				//如果有相同length()需要判断
			return o1.compareTo(o2);	//如果想顺序互换，可以o1,o2换位置
		}
		return num;
	}
}

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------