黑马程序员---集合的介绍与使用（1）（List，linkedlist，Arraylist；Set，hashSet）

于 2013-05-01 20:29:00 发布
阅读量373 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youngster890402/article/details/8872881
版权

------- android培训、java培训、期待与您交流！ ----------

集合类 Collection

1，为什么会出现集合类？---存储对象最常用的一种方式。

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2，数组和集合类同时容器，有何不同？

数组虽然也可以存储对象，但长度是固定；集合长度是可变的。

数组中可以存储基本数据类型，集合只能存储对象。

3，集合类的特点

集合只用于存储对象；

集合和长度是可变的；

集合可以存储不同类型的对象。

集合框架：

为什么会出现这么多的容器呢？

因为每一个容器对数据的存储方式都有不同。

存储方式即数据机构

 

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

2，集合中存储的都是对象的引用（地址）

什么是迭代器？

就是集合的取出元素的方式。。

import java.util.*;
class  CollectionDemo
{
	public static void main(String[] args) 
	{
	}
	public static void method_get()//取出元素
	{
		ArrayList al=new ArrayList();
		al.add("1");
		al.add("2");
		al.add("3");
		al.add("4");

		Iterator it=al.iterator();//获取迭代器，用于取出集合中的元素
		while(it.hasNext())//hasNext方法判断后返回boolean
		{
			sop(it.next());
		}
		//另一种写法
		for(Iterator it=al.iterator();it.hasNext();)
		{
			sop(it.next);
		}

	}
	public static void method_2()//交集
	{
		ArrayList al1=new ArrayList();
		al1.add("1");
		al1.add("2");
		al1.add("3");
		al1.add("4");
		ArrayList al2=new ArrayList();
		al2.add("1");
		al2.add("2");
		al2.add("5");
		al2.add("6");

		al1.retainAll(al2);//al1中只保留与al2中相同的元素 即12

		al1.removeAll(al2);//al1中去除与al2中相同的元素 即剩34

	}
	public static void method_base()
	{
		//创建一个集合对象。
		ArrayList al=new ArrayList();
		al.add("1");
		al.add("2");
		al.add("3");
		al.add("4");

		//打印集合
		sop(al);
		//删除元素
		al.remove("2");
		//获取个数
		sop(al.size());
		//清空集合
		al.clear();
		//元素是否存在
		sop(al.contains("2"));
		//集合是否为空
		sop(isEmpty());

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}


* Collection

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

 * |--ArrayList：底层的数据接口使用的是数组结构，特点查询很快但是增删稍慢。线程不同步

 * |--LinkedList：使用的是链表结构，查询稍慢但增删很快

 * |--Vector：底层是数组数据结构，线程同步。被ArrayList替代了。

 * |--Set: 元素是无需的，元素不可以重复。

 * 

 * List：

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

 * 增

 * add(index,element);

 * addAll(index,Collection);

 * 删

 * remove(index);

 * 改

 * set(index,element);

 * 查

 * get(index);

 * subList(from,to);

 * listIterator();

 * 

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

 * 在迭代时，不可以通过使用集合对象的方法操作集合中的元素，会发生异常。

 * 所以只能通过迭代器的方法操作，但是Iterator有局限性（只有判断取出删除的方法）。所以一般使用其子接口ListIterator。

 * 可以实现在遍历过程中对元素的增删改查。

 * 该接口只能通过List的Iterator接口获取

import java.util.*;
class ListDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method()
	{
		ArrayList<String> al=new ArrayList<String>();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		sop("原集合"+al);
		//在指定位置添加元素
		al.add(1,"java09");
		sop(al);
		//删除指定位置的元素
		//al.remove(2);
		//修改元素
		al.set(1, "java06");
		//通过角标获取元素
		sop(al.get(1));
		//获取所有元素
		for(int x=0;x<al.size();x++)
		{
			System.out.println(al.get(x));
		}
		//迭代器的
		Iterator it=al.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
		//通过indexOf获取对象位置。
		sop(al.indexOf("java01"));
		
		List sub=al.subList(1, 3);
		sop(sub);
		
	}
	public static void main(String[] args)
	{
	
		//列表迭代器：listIterator
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		ListIterator li=al.listIterator();
		
		while(li.hasNext())
		{
			Object obj=li.next();
			
			if(obj.equals("java01"))
				//li.add("java00");
				li.set("java-1");
		}
		sop(al);
		sop(li.hasNext());//false
		sop(li.hasPrevious());//true
}

}


import java.util.*;
/*
 * LinkedList特有方法：
 * addFirst();
 * addLast();
 * 
 * getFirst();
 * getLast();//获取不删除
 * 
 * removeFirst();
 * removeLast();//获取且删除。如果集合中没有元素会出现NoSuchElementException
 * 
 * 在JDK1.6出现了替代方法。
 * 
 * offerFirst();
 * offerLast();
 * 
 * peekFirst();
 * 
 * pollFirst();没有元素返回null。
 * 
 * 
 * */
class LinkedListDemo 
{
	public static void main (String[] args)
	{
		LinkedList link=new LinkedList();
		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");
		//倒序的，addLast是正的
		
		//sop(link);
		//sop(link.getFirst());//取第一个元素
		
		while(!link.isEmpty())
		{
			sop(link.removeFirst());//取出元素
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}


/*
 * 使用LinkedList模拟一个堆栈或者队列数据结构
 * 
 * 堆栈：先进后出
 * 队列：先进先出*/
import java.util.*;
class DuiLie
{
	private LinkedList link;
	DuiLie()
	{
		link=new LinkedList();
		
	}
	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}
	public Object myGet()
	{
		return link.removeLast();//若此处用removeFirst()则此程序可模拟堆栈
	}
	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());
		}
	}
}


去除ArrayList集合中的重复元素

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


*Collection的另一个派系Set

 *  |--Set: 元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。

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

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

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

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

所以定义对象（如Person）时，内部要复写hashCode和equals。

Tip：对于判断元素是否存在以及删除都是依赖于hashCode和equals方法。

ArrayList依赖于equals，这是由于数据结构不同。

Set集合的功能和Collection是一致的（List有特有的（因为其有角标什么的），但是Set没有）

import java.util.*;
class HashSetTest 
{
	public static void main(String[] args)
	{
		HashSet<Person> hs=new HashSet<Person>();
		
		hs.add(new Person("ap1",12));
		hs.add(new Person("ap2",17));
		hs.add(new Person("ap3",15));
		hs.add(new Person("ap4",18));
		hs.add(new Person("ap4",18));//去重就要重写equals
		
		Iterator<Person> it=hs.iterator();
		
		while(it.hasNext())
		{
			Person p=(Person)it.next();
			sop(p.getName()+"..."+p.getAge());	
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//此处复写hashCode方法，
	public int hashCode()
	{
		//return 30;
		return name.hashCode()+age*54;//age后可以自定义乘以一个数，为了保证返回的hashCode唯一。此处可以定义相同名字姓名的对象以相同的哈希值，便于后边调用equals方法。
	}
	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;//没有调用此equals方法，因为对象已经存入。所以要复写Person对象的哈希方法即hashCode（）
	}
	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}


youngster890402
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值