黑马程序员——集合基础(一)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、集合

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

2、集合与数组辨析

A) 容器长度：

集合长度可变

数组长度固定

B) 存储内容类型：

集合存储引用数据类型

数组存储任意类型

C) 是否可存储不同类型数据:

集合可以存储不同类型数据

数组只能存储相同数据类型

 

二、Java中的集合

1、JDK为我们提供了一套完整的容器类库，这些容器可以用于存储各种类型的对象，并且长度都是可变的，我们把这些类统称为集合类，它们都位于java.util包中。

2、分类：

A) 单列集合Collection：

List：元素有序、包含重复元素

Set：元素无序、不包含重复元素

B) 双列集合Map：键值映射关系

C) 其他功能接口：

a、迭代器Iterator

b、Comparable

c、Comparator

3、集合类的关系图

三、Collection接口：单列集合的根接口

1、主要方法

A、添加：

boolean add(E e) 向该集合添加一个元素

boolean addAll(Collection c) 添加一个集合中的所有元素到该集合

B、删除：

boolean remove(Object o) 删除集合中指定的对象

boolean removeAll(Collection c) 从集合中删除集合c中的所有元素

void clear() 将集合中的元素全部删除，集合长度变为0

C、判断：

boolean contains(Object o) 集合中是否包含指定元素

boolean containsAll(Collection c) 集合中是否包含集合c中所有的元素

boolean isEmpty() 集合是否为空

D、获取：

Int size() 集合中元素的个数

E、取交集：

boolean retainAll(Collection c) 仅保留此collection中那些也包含在指定collection中的元素

F、集合转为数组：

Object[] toArray() 返回包含此 collection 中所有元素的数组

G、返回迭代器 (获取集合中所有元素)：

Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器

 

2、Iterator接口：单列集合的迭代器。迭代器会像地震搜救队的方式一样去遍历集合中的每一个元素。Iterator仅用于遍历集合，Iterator本身并不提供盛装对象的能力。Iteator必须依附于Collection对象，它包含对所属集合的数据结构中的数据项的引用。如果需要创建Iterator对象，则必须有一个被迭代的集合

A、主要方法

boolean hasNext()  如果仍有元素可以迭代，则返回 true

E next()  返回迭代的下一个元素

 

B、使用固定格式：

格式一：
	Collection c = new ArrayList();
	Iterator it = c.iterator();
	while(it.hasNext()){
    		System.out.println(it.next());
	}
格式二:
	for(Interator it = c.iterator();it.hasNext();){
      		System.out.println(it.next());
	}

 

四、List

List：单列集合，可存放重复元素，元素有序。

1、主要子类：

ArrayList：底层数据结构是数组结构。线程不安全的。所以ArrayList的出现替代了Vector。增删慢,改查快。

LinkedList：底层是链表数据结构。线程不安全的，同时对元素的增删操作效率很高。

Vector：底层数据结构是数组结构。jdk1.0版本。线程安全的。无论增删还是查询都非常慢.已被ArrayList替代。

2、特殊方法

A、添加：

void add(int index, E element) 在指定的索引位插入元素

B、删除：

E remove(int index) 删除指定索引位的元素。返回被删的元素

C、获取：

E get(int index) 通过索引获取指定元素

List<E> subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图

int indexOf(Object o) 获取指定元素第一次出现的索引位，如果该元素不存在返回-1，通过-1，可以判断一个元素是否存在

int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1

D、修改：

E set(int index, E element) 用指定元素替换列表中指定位置的元素

E、返回迭代器：

ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。 

注意：用于应对并发修改异常

3、ListIterator：list特有的迭代器，内含避免并发修改异常的算法。

List比Collection多了修改的功能，当要对List集合中的数据遍历过程中需要修改数据，那就要用到list里的listIterator()，不然会发生异常。因为子类的特有数据修改时子类最清楚，父类是不知道的。

A、主要方法：

boolean hasNext() 以正向遍历列表，如果仍有元素可以迭代，则返回 true

E next()  返回迭代的下一个元素

boolean hasPrevious() 以逆向遍历列表，如果仍有元素可以迭代，则返回 true

E previous() 返回迭代的前一个元素

void add(E e)  将指定的元素插入列表

void remove() 从列表中移除由 next 或 previous 返回的最后一个元素

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素

 

五、LinkedList：

LinkedList：与ArrayList不同，LinkedList是方便添加删除的List。

主要方法：

A、添加：

public void addFirst(E e)

public void addLast(E e)

Jdk1.6以后：

public boolean offerFirst(E e) 在此列表的开头插入指定的元素。

public boolean offerLast(E e) 在此列表末尾插入指定的元素

B、获取：

public E getFirst()

public E getLast()

Jdk1.6以后：

public E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null

public E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null

C、删除：

public E removeFirst() 

public E removeLast() 

Jdk1.6以后：

public E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null

public E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null

六、Vector

Vector：安全的List，Vector中提供了一个独特的取出方式，就是枚举Enumeration。此接口Enumeration的功能与 Iterator 接口的功能是重复的。

主要方法：

public E elementAt(int index) 返回指定索引处的组件。

public E firstElement() 返回此向量的第一个组件（位于索引 0) 处的项

public E lastElement() 返回此向量的最后一个组件

public void setElementAt(E obj, int index) 将此向量指定 index 处的组件设置为指定的对象

public void removeElementAt(int index) 删除指定索引处的组件

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

 

七、Set

Set：单列集合，无序，元素不得重复。与Collection方法一致。Set集合取出元素只能使用迭代器。

Set主要子类

1、HashSet：线程不安全，存取速度快。底层结构为哈希表结构，即区分元素时使用hash值。可以通过hashCode与equals方法的重写，保证元素唯一性。具体代码体现为：先判断哈希值是否相等，再判断equals方法是否返回true。true则为相同元素，存储元素失败，false则为不同元素，存储元素成功。

例如：

package test;

import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
	public static void main(String[] args) {

		HashSet<MyDog> hashSet = new HashSet<MyDog>();
		hashSet.add(new MyDog("kitty",2));
		hashSet.add(new MyDog("kitty",2));
		hashSet.add(new MyDog("tom",3));
		hashSet.add(new MyDog("coffee",4));
		hashSet.add(new MyDog("jim",1));
		
		Iterator<MyDog> it = hashSet.iterator();
		while (it.hasNext()) {
			MyDog myDog = it.next();
			System.out.println(myDog);
		}
	}
}

class MyDog {
	private String name;
	private int age;
	public MyDog() {
		super();
	}
	public MyDog(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof MyDog) {
			MyDog a = (MyDog)obj;
			return this.name.equals(a.name);
		}
		else 
			return false;
	}
}

 

2、TreeSet： 线程不安全，可以对集合中的元素进行排序。通过Comparable让集合内元素具备比较性，通过Comparator让集合具备比较某种类型元素的能力。当Comparator与Comparable冲突时，以Comparator作为标准。

例如：

package set;
class Student implements Comparable<Student>{//该接口强制让学生具备比较性
	private String name;
	private int age;
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public int compareTo(Student s) {
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
			return this.name.compareTo(s.name);
		return -1;
	}	
}

class MyComparator implements Comparator<Student>{
	@Override
	public int compare(Student s1, Student s2) {
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		return num;
	}
}

package set;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Student> ts = new TreeSet<Student>();
		ts.add(new Student("lisi002",20));
		ts.add(new Student("lisi003",24));
		ts.add(new Student("lisi005",25));
		ts.add(new Student("lisi009",28));
		ts.add(new Student("lisi002",20));
		
		Iterator<Student> it = ts.iterator();
		while (it.hasNext()) {
			Student stu = it.next();
			System.out.println("name:"+stu.getName()+",age:"+stu.getAge());
		}
	}
}

 

3、LinkedHashSet：在HashSet集合的基础上，使迭代顺序可预测

 

 

八、其他

1、Collection体系最常用的集合为ArrayList。

2、当数据从数据库读出时，通常是使用ArrayList接收多个对象，从而使用该集合进行数据的传递。通常页面展示数据时，使用ArrayList作为最后数据的容器。

3、TreeSet的排序功能在日常开发中使用的并不广泛。

4、LinkedList常用于发生修改的数据。

5、foreach循环：又叫增强for循环，是迭代器的简写形式

(1)是针对数组和Collection集合进行遍历的一种方式。

(2)格式：

for(数组或者Collection集合中的元素的数据类型 变量名 : 数组或者Collection集合对象) {

直接使用变量名即可，这个时候的变量名其实就是元素。

 }

例如：A与B的效果一样
	A：	for(String s : al){
			System.out.println(s);
		}
		
	B：	Iterator<String> it = al.iterator();
		while (it.hasNext())
		{
			String str = it.next();
			System.out.println(str);
		}

(3) 注意：

A:增强for的底层封装了迭代器的操作。

B:在使用增强for的时候，请保证迭代目标不为null。

C:增强for循环只能做展示数据的功能，不能修改数据。