关闭

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

365人阅读 评论(0) 收藏 举报
分类:

---------------------- <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>、期待与您交流! ----------------------

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:11337次
    • 积分:349
    • 等级:
    • 排名:千里之外
    • 原创:26篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档