黑马程序员_java 集合框架学习总结

-------<a href="http://www.itheima.com/"">android培训</a>、<a href="http://www.itheima.com/"
">java培训</a>期待与您交流！----------

黑马程序员_ java集合框架学习总结

java中的集合框架是指java中各种不同的集合所构成的体系。

集合是按照各自特有的数据结构存储对象的容器。在软件编程中合理的使用集合，可以大大的提高程序运行的效率，也使得编程工作更加灵活。

java语言中存储对象的容器有两个，数组与集合。他们的区别是：

数组的长度是固定的一被实例化后就不能改变长度。

集合的长度是可变的。

数组可以存储基本数据类型和对象。

集合只可以存储对象。（但在java中有什么不是对象呢？基本数据类型也可以包装为对象）

集合比数组提供了更加强大丰富的方法。

集合框架体系：

Iterable<---------Collection Map

ListIterable<- -List Set HashMap TreeMap

ArrayList Vectory LinkedList HashSet TreeSet

从上图可以看出集合框架的根类是Collection和Map,Collection集合实现了Iterable接口。说明所有的Collection集合都是可以被迭代的。可以看出java有很多集合，之所有很多集合，因为每种集合都有其特有的数据存储方式，即数据结构。来解决编程实际的需要。

Iterator(迭代器)：

Collection系的集合都实现了Iterable接口，都有自己的迭代器。

迭代器是集合元素的一种取出方式。每个Collection集合都可以根据其的iterator()得到自己迭代器。但由于每个集合都有自己特殊都数据结构，所以每个集合都通过内部类实现Iterator接口，送出自己特有的迭代器。

Iterator接口方法：

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

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

remove()从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

下面代码是演示如获取Arraylist的迭代器，并通过迭代器遍历集合元素并打印到控制台。

ArrayList al=new ArrayList();

for(Iterator it=al.iterator();it.hasNext();){

system.out.println(it.next);

}

Collection集合共有方法：

boolean add(E e) 向集合末尾添加元素。如果改变了集合则返回true。

boolean addAll(Collection<?extendsE>c) 将指定的集合元素添加到该集合中，成功则返回true。

int size()返回集合长度。

boolean isEmpty().判断集合是否为空。

<T>T[] toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同.该方法是集合到数组的桥梁。

boolean contains(E e):判断集合是否包含指定对象。

boolean containsAll(Collection<E>):判断集合是否包含指定集合的所有元素。

boolean retainAll(Collection<E>)仅保留此collection 中那些也包含在指定 collection 的元素.即取交集。

boolean remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话返回true。

boolean removeAll(Collection<？>) 移除此 collection 中那些也包含在指定 collection 中的所有元素。

boolean add(E e) 确保此 collection 包含指定的元素（可选操作）。

boolean addAll(Collection<? extends E> c)

将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

void clear() 移除此 collection 中的所有元素（可选操作）。

boolean contains(Object o)

如果此 collection 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)

如果此 collection 包含指定 collection 中的所有元素，则返回 true。

boolean equals(Object o)比较此 collection 与指定对象是否相等。

Iterator<E> iterator(）返回在此 collection 的元素的迭代的迭代器。

Collerction集合下的两大子系集合：List Set

List:数据结构特点是元素是有序的（存入元素与取出元素的顺序是一致的），该集合的元素有索引，元素可以重复。

Set:数据结构的特点是：元素是无序的。无索引，元素是不可以重复的

List集合共有方法。

boolean add(int index) 在集合指定位置添加元素。

boolean addAll(int index,Collection<E> c)在集合指定位置添加参数集合的所有集合。

int indexOf(Object o)返回指定对象在集合第一次出现的位置。如果该对象在集合中不存在则返回-1.

E get(int index) 返回指定位置的元素对象。通过该方法可以不需要迭代器遍历List集合。

如下代码：

ArrayList al=new ArrayList();

for(int i=0;i<al.size();i++){

System.out.println(al.get(i));

}

E boolean remove(int index)删去集合指定位置的元素。并返回被删去的元素。

set(int index,E e) 将集合指定位置的元素改为参数对象。

list subList(int start,int end) 得到一个新的List集合。该集合元素是原集合指定范围类的元素们。

从以上List集合的方法中可以看出带有与索引有关的操作都List的特有方法。

list集合不仅实现了Iterable还实现了其子接口，ListIterable.List集合还有自己特有的迭代器，ListIteator.那List集合为什么还需要自己特有的迭代器呢？

先了解一个操作集合的常见异常ConcurrentModificationException.当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

举例说明当用List的普通迭代器Iterator遍历集合时，如果这时再用集合本身的方法去改变集合时就会抛出

ConcurrentModificationException异常。因为迭代器只是引用了被集合方法操作前的集合，它并不能知道被集合方法改变后的集合。

但是普通的迭代器的方法有限，基于List集合元素有索引，List集合提供了功能更丰富的迭代器，方便我们在遍历集合时对集合进行增 删 改 查。

List特有迭代器ListIteator方法总结

boolean add(E e) 在集合末尾添加元素。

boolean hasperious()判断前面还有没有元素。可以用来逆向遍历集合。

E pervious() 返回前面一个元素

List常见子类集合ArrayList LinkedList Vector

ArrayList:是数组数据结构。特点查询，修改元素效率高，增删元素效率低，是不同步的。被创建时，初始长度为10，元素个数超过容量，集合长度自动50%延长。

LinkedLIst:是链表数据结构。特点是，增删元素效率高，查询修改元素效率低。是不同步的。被创建时，初始长度为10，元素个数超过容量，集合长度自动50%延长。

Vector:该集合是老版本的集合，已被ArrayList代替。是同步的。

但其的迭代方法Enumeration在IO中的SequenceInputStream中仍被使用，所以仍需了解。

Enumeration接口，可以通过Vector的elements（）方法获得。其抽象方法有：

boolean hasMoreElements（）测试此枚举是否包含更多的元素

当且仅当此枚举对象至少还包含一个可提供的元素时，才返回 true；否则返回 false。

E nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

LinkedList集合的特有方法

boolean offerFrist(E e) 将元素添加到集合的第一位。

boolean offerLast(E e) 将元素添加到集合的末尾。

boolean peekFrist(E e) 获取但不删去集合的第一个元素。

boolean peekLast(Eｅ)　获取但不删去集合中的最后一个元素。

boolean pollFrist(E e) 获取并删去集合中第一个元素。

boolean pollLast(E e) 获取并删去集合中最后一个元素。

注意：List集合contains remove等涉及到要比较元素是否相等的方法都是根据元素的equals()方法。所以在List集合存储自定义对象时，要覆盖equals()。定义自己自定义的比较元素是否相等的方法。通过以下代码演示上述内容。

package com.itheima.jihe;

import java.util.ArrayList;

import java.util.ListIterator;

/*

* 写一个去除ArrayList集合重复元素的集合。

* 存的是自定义对象。

*

* 重点：集合中的contains()remove()方法原理都是调用

* 元素对象的equal()方法进行比较。我们要对自己的自定义对象

* 进行复写equal()方法。

*/

public class ArrayListPractise {

public static void main(String[] args) {

// TODO Auto-generated method stub

//定义ArrayList集合对象。并向集合中添加自定义对象。

ArrayList al=new ArrayList();

al.add(new People("mulele", 20));

al.add(new People("mulele", 20));

al.add(new People("mulele1", 22));

al.add(new People("mulele2", 21));

al.add(new People("mulele", 20));

ArrayList a =getInstanceArrayList(al);

System.out.println(a);

}

public static ArrayList getInstanceArrayList(ArrayList al){

ArrayList al1=new ArrayList();

for(ListIterator lit=al.listIterator();lit.hasNext();){

Object obj=lit.next();

if(!al1.contains(obj)){

al1.add(obj);

}

}

return al1;

}

}

//定义一存储到集合里的类，并覆盖equal()。定义自己的对象比较是否相等的方式。

class People{

private String name;

private int age;

public People(String name,int age) {

this.name=name;

this.age=age;

}

public boolean equals(Object obj) {

if(!(obj instanceof People)){

return false;

}

People p=(People)obj;

return this.name.equals(p.name)&&this.age==p.age;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return this.name+this.age;

}

}

Set集合是无序的。set的方法与Collection方法一致。元素不能重复。

Set集合的常见子类。

HashSet:底层数据结构是哈希表数据结构。

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

是通过元素的两个方法。hashCode()与equals()。

当元素被存入集合时，会根据元素的hashCode()方法算出元素哈希值。如果该哈希值在集合中不存在则该元素被存入集合，是唯一的。如果存在则调用该元素的equals()与集合中其他元素比较，如果相等则不能存入集合，不相等则存入集合。

因此在自定义对象存入HashSet集合时，要覆盖对象的hashCode()和equals()。

TreeSet集合

TeeSet集合更像HashSet集合的升级版。不仅保证了元素的唯一性，还可以自定义排序规则对集合里的元素 进行排序。

TreeSet集合保证元素唯一性的的的方式有两种。

第一种方式：根据元素的的compareTo()方法。

这时存在TreeSet集合的元素对象必须实现Comparable接口，实现compareTo()方法，让元素对象具备可比较性。

第二种方式：如果元素对象没有实现Comparable接口，或者具备的比较性不是所需要的，这时可以让集合具有比较器，来以此保证元素的唯一性并给元素排序。

通过TreeSet的构造函数TreeSet(Compator<?super E> c)

接受一个比较器对象。

创建比较器对象，必须实现比较器接口实现compare(Tt1,T t2)方法。

通过以下代码来演示以上两种方式。

package com.itheima.jihe;

/*

* 向TreeSet存储自定义student类。并按年龄排序

*/

public class TreeSet {

public static void main(String[] args) {

// TODO Auto-generated method stub

java.util.TreeSet tree=new java.util.TreeSet();

tree.add(new Student("mulele",20));

tree.add(new Student("gaojinge",21));

tree.add(new Student("mulele",22));

tree.add(new Student("mulele",20));

System.out.println(tree);

}

}

class Student implements Comparable{

String name;

int age;

public Student(String name,int age) {

this.name=name;

this.age=age;

}

//复写compareTo()先以性命为排序依据，姓名相同以年纪为依据。

public int compareTo(Object obj) {

if(!(obj instanceof Student))

throw new RuntimeException();

Student stu=(Student)obj;

int result= this.name.compareTo(stu.name);

if(result==0){

return this.age-stu.age;

}

return result;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return this.name+"...."+this.age;

}

}

package com.itheima.jihe;

import java.util.Comparator;

import java.util.TreeSet;

import javax.management.RuntimeErrorException;

/*

*将字符串存入TreeSet集合，字符串长度为依据排序

*/

public class TreeSet2 {

public static void main(String[] args) {

// TODO Auto-generated method stub

//将比较器传给TreeSet集合的构造函数用匿名内部类的方式

TreeSet tree=new TreeSet(new Comparator() {

@Override

public int compare(Object o1, Object o2) {

// TODO Auto-generated method stub

if(!(o1 instanceof String&&o2 instanceof String))

throw new RuntimeException();

String s1=(String)o1;

String s2=(String)o2;

int result=s1.length()-s2.length();

if(result==0){

return s1.compareTo(s2);

}

return result;

}

});

tree.add("sdfg");

tree.add("s");

tree.add("sdf");

tree.add("dfgh");

tree.add("sdfg");

System.out.println(tree);

}

}

Map<K,V>集合是java集合框架中与Collection集合平级的集合。该集合是存储键值对的。是一对对存储元素并保证键的唯一性。

Map的常见共性方法。

获取

V get(Object key) 根据建获取值

int size() 获取元素长度。

Set<V> vaule() 返回一个set集合，集合里的元素为map集合里的所有值。

删除：

clear() 移除集合里所有的元素。

V remove(Object key) 根据键删除与键相对的值。并返回该值。

判断：

boolean contains(object key)判断集合里是否包含指定的键。

boolean containsVaule(Object vaule)判断集合是否某个值。

boolean isEmpty()判断元素是否为空。

添加：

V put(K key,V vaule) 添加与key关联的vaule如果该key存在则将新的vaule替换掉旧的vaule。并返回旧的vaule.如果该key不存在则集合存储该key和vaule并返回空。这个方法同样可以判断某个key是否在集合中存在。

putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

Map常见子类

HashMap:底层数据结构是哈希表数据结构。可以存在null的键与值。是不同步的。

HashTable:底层数据结构是哈希表数据结构。不可以存在null的键与值。是同步的。

TreeMap: 底层数据结构是二叉数数据结构。可以存在null的键与值。是不同步的。

HashTable是老版本的集合已被HashMap取代。

Map集合的两种取出方式。

第一种：利用Map集合的keySet()方法获取一个包含Map所有键的Set集合。迭代Set集合，再根据Map的get(K key)方法获取Map集合的值。

第二种：利用set<Map.Entry<K,V>>entry()方法将Map集合的映射关系存入Set集合。迭代Set集合利用Map.Entry的方法getKey(),getValue(),获取Map集合的键与值。以下代码演示Map集合的两种取出方式。

package com.itheima.jihe;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

public class Map集合的取出两种方式 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Map<String, String> map = new HashMap<String, String>();

map.put("01", "java");

map.put("02", "javase");

map.put("03", "javaee");

map.put("04", "android");

map.put("05", "c++");

/*取出方式二利用entrySet()

Set<Map.Entry<String, String>> set = map.entrySet();

for (Iterator<Map.Entry<String, String>> it = set.iterator(); it

.hasNext();) {

Map.Entry<String,String>me=it.next();

System.out.println(me.getKey()+"=="+me.getValue());

}*/

//取出方式一

Set<String>set=map.keySet();

for(Iterator<String>it=set.iterator();it.hasNext();){

String key=it.next();

String vaule=map.get(key);

System.out.println(key+"=="+vaule);

}

Properties p= System.getProperties();

for(Object obj:p.keySet()){

String s=(String)p.get(obj);

System.out.println(obj+":::"+s);

}

}

}

集合框架的工具类

Collections

该类是为提供操作集合的工具类，该类的所有方法都是静态的可以直接调用。

常用方法：

static <T extends Comparable<? super T>>

void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序

sort(List<T> list, Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。

max(Collections<? extends T> c)获取元素的最大值，根据集合元素的compareTo()。

max(Collections<? extends T> c,Compator(? super T)com)获取集合元素的最大值根据集合的比较器。

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

使用二分搜索法搜索指定列表，以获得指定对象。根据元素自身的compareTo()

static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

使用二分搜索法搜索指定列表，以获得指定对象。根据集合的Compator比较器。

注意：使用上述两个方法查找元素必须保证集合是有序的List集合。

扩展：如果用上述方法去找一个集合中不存在的对象（当然该对象与集合元素同属一类不违反泛型机制可以存入该集合）

上述方法会返回一个int值。该值就是在保持集合顺序不变，将该对象插入到集合的索引取反在减去一。所以同样可以根据上诉方法得到一个对象插入集合，保持集合顺序变，该对象的索引值。索引值是方法返回值+1在取反。

fill(List<？super T>list,T t)将指定对象填充到指定list集合替换掉该集合的所有元素。

reverse(List<T>list)反转指定List集合。

Comparator reveseorder() 返回一个比较器，他能反转Collection根据元素compareTo()排序元素的循序。

Comparator reveseorder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

swap(List<T>list,int i1,int i2)将制定位置值得集合元素互换位置。

shuffle(List<?>list)

随机给指定元素排序。

数组操作工具类 Arrays

Arrays是操作数据是的工具类，提供了很多有用的便于我们使用数组的方法。

重要方法：数组变集合 asList()注意只能变为List集合。

数组变为集合有力与我们能将操作集合的思想与方法用在操作数组上。

注意，将数组变为集合时不能对变成集合后的数组进行增删操作。

其他常用类总结

Runtime类是java应用程序与程序所处的环境（操作系统）相连接的类。该类的实例对象不能用new创建。必须通过其getruntime()获取对象。

常用方法有

process exec(String commd)执行系统命令并返回一个进程对象。调用该进程对象的descory()方法可以杀死该进程。

Math类提供了一些数学计算的方法。

Random此类的实例用于生成伪随机数流。

常用方法：

int nextInt()返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

long nextLong() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

-------<a href="http://www.itheima.com/"">android培训</a>、<a href="http://www.itheima.com/"
">java培训</a>期待与您交流！----------