黑马程序员----------List，Set笔记

集合框架

一、概述：

1、简述：

      所谓集合，就是为方便对多个对象的操作，对对象进行存储。集合就是存储对象最常用的一种方式。

2、集合与数组的区别：

      数组：可存储同种类型的数据，但长度固定，也可存储基本类型的数据

      集合：只可存储对象，长度可变，类型可以任意对象。

3、集合的特点：

      只用于存储对象，长度可变，也可存不同类型的对象。

      集合是一个接口，将每种容器的共性提取，形成的一个体系。

4、数据结构：

      由于每种容器对数据的存储方式都各不相同，所以出现了不同的容器。此种存储方式称之为数据结构。

集合框架的构成及其分类

* Collection中有哪些方法呢？
 1，添加方法。 

 boolean add(object e):    添加元素。

boolean addAll(Collection):      将参数容器中的元素添加到当前容器中。
2，删除方法。
boolean remove(object):删除指定对象。 
boolean removeAll(Collection):删除指定collection中和本Collection中相同的元素。 
void clear():    清空元素。
3，判断方法：
boolean contains(object): 是否包含指定元素。
boolean containsAll(Collection):是否包含指定容器中的元素。 

boolean isEmpty(): 是否为空。

4，获取元素个数：
int size():获取元素个数。
5，取交集。
boolean retainAll(collection):保留和指定collection集合中相同的元素，不相同的元素会被删除。
 6，将集合转成数组。
Object[] toArray():
 7，取出元素的方法：
Iterator iterator():

集合框架中常用接口：

Collection接口有两个子接口：

List（列表） ，Set（集）

List：可存放重复元素，元素存取是有序的。

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

List接口常用类：

Vector：线程安全，但速度慢，已被ArrayList替代。

ArrayList：线程不安全，查询速度快。

LinkedList：链表结构，增删速度快。

取出LIst集合中元素的方式：

get(int index)：通过脚标获取元素。

iterator()：通过迭代方法获取迭代器对象。

迭代是取出集合中元素的一种方式。

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

List用法：

 演示List子接口中的特有方法。
因为该接口的特点是 对元素有索引标示。

 所以它的特有方法应该都是围绕着索引定义的。 
 1，添加：
void add(index,element);

boolean addAll(index,collection);
 2，删除：
object remove(index):获取并删除。记住大家，增加或者删除方法的成功都会改变集合的长度。
3，获取： 获取元素：Object get(index):获取
获元素索引：int indexOf(object); int lastIndexOf(object);
 获取子列表： List subList(fromIndex,toIndex):获取列表中的一部分，包含fromIndex位置，不包含toIndex位置。
 4，修改。
object set(index,element):替换指定位置的元素，并返回被替换掉的元素。
 我们发现，List接口是可以对元素进行增删改查的操作的。

public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	
	public static void main(String[] args) 
	{
		methodAdd();
		//methodListIterator();
	}

	public static void methodAdd()
	{
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList list = new ArrayList();
		//1.添加元素--->add(Object obj),多态 
		list.add("java01");
		list.add("java02");
		list.add("java03");
		list.add("java04");
		ArrayList list2 = new ArrayList();
		//1.添加元素--->add(Object obj),多态 
		list2.add("java05");
		list2.add("java06");
		list2.add("java07");
		list2.add("java08");

		//打印原集合
		sop("原集合:" + list);
		sop("------------------");
		//1.在某一个位置上添加元素：add(int index,"新元素")
		list.add(1,"java001");
		sop("增加后的集合：" + list);
		sop("---------");
		list.addAll(1,list2);
		sop("在list中1位置后添加list2：" + list);
		sop("------------------");
		//2.删除指定位置上的元素：
		list.remove(2);
		sop("删除后的集合：" + list);
		sop("------------------");
		//3.改变某一位置上的元素：set(int index,"要改成的元素")
		list.set(2,"java007");
		sop("改变角标为2的元素后的元素:" + list);
		sop("------------------");

		//4.获取元素：get()
		list.get(1);
		sop("获取角标为1上的元素:" + list.get(1));
		sop("------------------");

		//通过某个元素获取其在集合中的位置--indexOf("查找的元素")
		int m = list.indexOf("java007");
		sop("获取“java007”所在的位置：" + m);

		//获取从某个位置到另一位置上的元素subList()
		List l = list.subList(1,3);
		sop("获取从位置1到3上的元素:" + l);
		sop("------------------");

		//4.获取全部元素
		//get方法的for循环
		sop("get方法：");
		for (int i=0;i<list.size();i++)
		{
			sop("list(" + i + ")" + list.get(i));
		}
		sop("------------------");

		//迭代器方法：Iterator()
		for (Iterator it = list.iterator();it.hasNext(); )
		{
			sop("next:" + it.next());
		}
		sop("------------------");
}

	public static void methodListIterator()
	{
		//演示列表迭代器：
		ArrayList list = new ArrayList();
		//1.添加元素--->add(Object obj),多态 
		list.add("java01");
		list.add("java02");
		list.add("java03");
		list.add("java04");

		//打印原集合
		sop("原集合:" + list);
		sop("------------------");

		

		//在迭代过程中，准备添加或删除元素
		for (ListIterator it = list.listIterator();it.hasNext(); )
		{
			Object obj = it.next();
			if (obj.equals("java01"))
				it.remove();
			else if(obj.equals("java02"))
				it.add("增加java200");
			else if(obj.equals("java03"))
				it.set("修改为java300");
			sop("obj:" + obj);
		}
		sop("list :" + list);
	}

 注意：只有这个集合具备着增删改查。具备的原因：因为有索引。 

定义一个功能，去除ArrayList中的重复元素。

实现代码：

	public static void main(String[] args) {

		ArrayList al = new ArrayList();
		al.add(new Person("lisi1",21));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		al.add(new Person("lisi3",23));
		
		System.out.println(al);	
		al = getSingleElmenetList(al);
		System.out.println(al);
	}

	public static ArrayList getSingleElmenetList(ArrayList al) {
		
		//1,创建一个新集合。
		ArrayList temp = new ArrayList();
		
		//2,迭代原集合。 
		Iterator it = al.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			
			if(!temp.contains(obj)){//内部依赖的是equals方法。
				temp.add(obj);
			}
			
		}
		
		return temp;
	}

请用LinkedList模拟一个堆栈或者队列数据结构。

思路：

 介绍两种常见的数据结构。
 1，队列： 先进先出。FIFO  first in  first out
 2，堆栈： 后进先出。LIFO  Last in  first out

public class MyQueue {

	private LinkedList link = null;
	
	public MyQueue(){
		link = new LinkedList();
	}
	
	/**
	 * 往队列中添加元素。
	 */
	public void myAdd(Object obj){
		//调用的是LinkedList的方法。
		link.addLast(obj);
	}
	
	/**
	 * 获取队列中元素的方法。
	 */
	public Object myGet(){
		
		return link.removeFirst();
	}
	
	/**
	 * 队列中是否为空。
	 */
	public boolean isNull(){
		return link.isEmpty();
	}
}

定义一个功能，去除ArrayList中的重复元素。

思路：

 1，定义一个集合，用于存储唯一性的元素。
 2，迭代已有的集合，将每一个迭代到的元素都到新集合中判断是否包含。 如果包含就不存储，如果不包含就存储到新集合中。

 3，迭代结束，新集合中存储的都是不重复的元素。

public static ArrayList getSingleElmenetList(ArrayList al) {
		
		//1,创建一个新集合。
		ArrayList temp = new ArrayList();
		//2,迭代原集合。 
		Iterator it = al.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			if(!temp.contains(obj)){//内部依赖的是equals方法。
				temp.add(obj);
			}		
		}	
		return temp;
	}

Set接口常用的类：

HashSet：线程不安全，存取速度快。

TreeSet： 线程不安全，可以对Set集合中的元素进行排序。

Set集合元素唯一的原因：

HashSet：通过equals方法和hashCode方法来保证元素的唯一性。

TreeSet：通过compareTo或者compare方法中的来保证元素的唯一性。是以二叉树式存放的。

 要想让Person对象具备比较大小的功能。

就需要对person对象进行功能的扩展。
 让Person去实现Comparable接口。让Person具备自然顺序。 覆盖compareTo方法。

覆盖的compareTo方法为：

public int compareTo(Object o) {
		
		/*
		 * 按照Person对象的年龄进行排序。从小到大。
		 */
		
		/*
		 * 进行对象比较的时候，通常，先比较主要条件，如果主要条件相同，在比较次要条件。
		 * 如果想要按照人的年龄排序，如果年龄相同，在比较一次姓名。
		 */
		Person p = (Person)o;
		int temp = this.age - p.age;
		
		return temp==0?this.name.compareTo(p.name):temp;
		
	}