黑马程序员——java---集合

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

 

为什么出现集合类？

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

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

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储任意数据类型，集合只能存储对象。

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

我的总结：集合类比数组强大，类似于包装类与基本数据类型！

集合框架的构成及分类

 

两大接口

Java集合类主要由两个接口派生出来：

Collection

Set ：不能存放重复对象

List ：可存放重复对象，有序

Queue ：队列

SortedSet ：可对集合数据排序

Map

SortedMap ：可对集合数据排序

2、Collection接口

 Collection 是层次结构中的根接口（顶层接口）。有两个常用的接口List 和Set。在List
接口中有常用类ArrayList、LinkedList 和Vector；在Set 接口中有类HashSet、TreeSet

方法：

 boolean add(Object o):该方法用于向集合里面添加一个元素，若集合对象被添加操作改变了，返回true.

boolean addAll(Collection c):把集合c里面的所有元素添加到指定集合里面去，如果集合对象被添加操作改变了返回true.

void clear():清除集合里面的所有元素，将集合长度变为0。

boolean contains(Object o):返回集合里是否包含指定的元素。

boolean containsAll(Collection c):返回集合里是否包含集合c内所有的元素。

boolean isEmpty()：返回集合是否为空（长度是否为0）。

Iterator iterator():返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object o)：删除集合中指定元素o。

boolean removeAll(Collection c):从集合中删除集合c里面的元素。若删除一个或以上返回true。

boolean retainAll(Collection c):从集合中删除集合c里不包含的元素。

int size()：得到集合元素的个数。

Object[] toArray():把集合转成一个数组，所有集合元素编程数组元素。

import java.util.ArrayList;import java.util.Collection;public class DeMo1 {public static void main(String[] args) {//定义一个Arraylist集合。Collection<String> c = new ArrayList<String>();//向集合中添加元素。c.add("A");c.add("A");c.add("A");c.add("A");// c.add(new Date());上面写了泛型，这个语句就是错误的了，因为泛型规定了加进来的类型！System.out.println(c);}}

3、Iterator接口 

 

Iterator主要遍历Collection集合中的元素，也有称为迭代器或迭代精灵。

boolean hasNext()：若被迭代的集合元素还没有被遍历，返回true.

Object  next():返回集合的下一个元素.

void remove():删除集合上一次next()方法返回的元素。(若集合中有多个相同的元素，都可以删掉)

iterator对于集合才能用，for不同，只要是循环都可用。

 

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

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

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。（学到泛型就可以消除强转！）

Iterator it = l.iterator();while(it.hasNext()){System.out.println(it.next());}

4、集合遍历输出方式

 

Iterator：迭代输出

一旦操作集合的遍历输出，首选Iterator接口;

ListIterator:Iterator子接口，专门输出List中的元素;

Enumeration:古老的输出方式，迭代Vector元素，被Iterator取代;

foreach:可输出数组和Iterable对象;

 

我的总结：

集合遍历输出方式：

1. Iterable接口（迭代遍历）  注：优先选择Iterator接口，遍历Collection里所有元素，也称为迭代器和迭代精灵；迭代是取出集合中元素的一种推荐方式。

2. Foreach循环  注：可以直接用，使用场合：数组和Iterable对象！

3. For循环      注：在（）内实例化Iterable对象，进行遍历！

4. 先用toArray方法输出成为数组，再用Foreach循环！

第一个和第三个很类似，第二个和第四个很类似！

import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class DeMo2 {public static void main(String[] args) {//定义个arraylist集合。List<String> ls = new ArrayList<String>();//往集合中添加元素。ls.add("1");ls.add("2");ls.add("3");ls.add("4");System.out.println(ls);//遍历输出四中方式：//1、使用的Iterator对象，迭代输出。Iterator<String> it = ls.iterator();while(it.hasNext()){System.out.println("迭代输出："+it.next());}//2、对集合进行fore循环！（增强for循环）for(String str :ls){System.out.println("fore集合迭代输出："+str);}//3、for循环跌代。for(Iterator<String> it1 = ls.iterator();it1.hasNext();){System.out.println("for循环迭代输出："+it1.next());}//4、将集合转换成数组，再利用数组的遍历输出。Object[] o = ls.toArray();for(Object obj : o){System.out.println("数组迭代输出："+obj);}}}

List接口

Collection子接口；

List是有序的集合，集合中每个元素都有对应的顺序序列。List集合可使用重复元素，可以通过索引来访问指定位置的集合元素（顺序索引从0开始）,List集合默认按元素的添加顺序设置元素的索引,比如第一个元素的索引就是0,好似数组。

List作为Collection子接口当然拥有其所有方法，同时也有自己的方法：

 

void add(int index,Object e):将元素e添加到List集合中的index处；

boolean addAll(int index,Collection c):将集合c所包含的所有元素都插入在List集合的index处；

Object get(int index):返回集合index索引处的元素；

int indexOf(Object o):返回对象o在List集合中第一次出现位置的索引；

int lastIndexOf(object o):返回对象o在List集合中最后一次出现的位置索引；

Object remove(int index)：删除并返回index索引处的元素；

Object set(int index,Object e):把集合index处的元素替换为e对象，返回以前在指定位置的元素；

List subList(int fromIndex,int toIndex):返回从所有fromIndex(包括)到toIndex(不包括)处所有集合元素的子集合。

 

List接口中常用类

 

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

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

LinkedList：链表结构，增删速度快。取出List集合中元素的方式：

 

ArrayList特有方法：（凡是可以操作角标的方法都是该体系特有的方法）

添加：

在指定位置插入指定元素。

Void add（int index，Eelement）；

将所有的元素插入到列表中指定位置。

Boolean addAll（int index ， collection<? Extends E> c ）；

删除：

Remove（int index）；

修改：

Set（int index，Eelement）；

查：

获取位置索引。

Get（int index);

判断位置索引。如果不含该元素，返回-1

Int indexOf(Object o);

截取，包含头不包含尾。

Sublist(int fromIndex,int toIndex)；

从逆序遍历列表，

Boolean hasPrevious（）；

ListIterator：list特有迭代器。

 

Iterator的子接口，专门用于操作List集合的输出；

List自己还有一个listIterator()方法，该方法返回ListIterator对象，ListIterator继承了Iterator接口，提供了专门操作List的方法。在Iterator上额外增加的方法：

支持双向输出：

boolean hasPrevious():返回该迭代器关联集合是否还有上一个元素；

Object previous():返回该迭代器的上一个元素；

 

我的总结：这是相对更加特殊的一个接口，只用于List集合，可以完成逆序输出！

import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class DeMo3 {public static void main(String[] args) {//定义一个arraylist集合。List<Integer> ls = new ArrayList<Integer>();//往集合中添加元素。ls.add(12);ls.add(14);ls.add(21);ls.add(31);ls.add(33);System.out.println(ls);//使用list集合特有的迭代器迭代。ListIterator<Integer> it = ls.listIterator();while(it.hasNext()){System.out.println("正序："+it.next());//正序打印list集合。}System.out.println("---------------------");while(it.hasPrevious()){System.out.println("逆序："+it.previous());//list迭代器特有的方式。逆序遍历。}}}

 

Vector （枚举）

特有方法

添加组件。

Void addElement（）；

相当于get方法。

elementAt（int index）；

获取第一个组件。

firstElement（）；

插入。

insertElement（E obj，int  index）；

最后一个组件。

Last Element（）；

移除。

removeAllElements（）；

public Enumeration elements();//返回此向量的组件枚举

枚举就是Vector特有的取出方式。枚举和迭代是一样的，但枚举的名称和方法的名称都过长，所以就被迭代器取代了。

枚举Enumeration的方法摘要：

boolean hasMoreElements(): 测试此枚举是否包含更多的元素。

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

Enumeration是一个接口，此接口的功能与Iterator接口的功能是重复的。此外，Iterator接口添加了一个移除操作，并使用较短的方法名。新的实现应该优先考虑Iterator接口，而不是Enumeration接口。

import java.util.Enumeration;import java.util.Vector;public class DeMo5 {public static void main(String[] args) {//vector特有迭代方式。//定义一个wector。Vector v = new Vector();//往里面添加元素。v.add("java1");v.add("java2");v.add("java3");v.add("java4");//遍历元素。（特有的遍历方式）Enumeration en = v.elements();while(en.hasMoreElements()){//类似于hasNext。System.out.println(en.nextElement());//类似于next。}}}

 

LinkedList

LinkedList是List接口的链接列表实现。此实现不同步。

特有方法：

void addFirst( );

void addLast( );

获取元素，但不删除元素

getLast();

removeFirst();//获取元素，但删除元素，容量减少

removeLast();

当集合中没有元素时，使用上面的方法会出现没有这个元素异常

NoSuchElementException

我的总结：List 集合判断元素是否相同，依据的是元素的equals 方法。

Queue接口

 

继承Collection接口

模拟队列：先进先出(FIFO);

void add(Object e):将e插入到队列尾部；

Object element():获取队列头部的元素；

boolean offer(Object e):将e插入到队列的尾部，当使用有容量限制的队列时，此方法比add(Object e)方法更好。

Object peek():获取队列头部的元素。如果此双端队列为空，则返回 null。

Object poll():获取并删除队列头部的元素。如果此双端队列为空，则返回 null。

Object remove():获取并删除队列头部的元素。

Set接口（元素不可以重复）

 

Set是Collection子接口；

Set和Collection基本上一样，一点除外：

Set无法记住添加的顺序，不允许包含重复的元素。

当试图添加两个相同元素进Set集合，添加操作失败，add()方法返回false。

Set判断两个对象是否相等用equals,而不是使用==。

也就是说两个对象equals比较返回true，Set集合是不会接受这个两个对象的。

常用子类：

1.HashSet:散列存放

 HashSet : (JDK1.2) 底层数据结构是哈希表。元素唯一、线程不安全，非同步。但效率
高。允许使用null。元素。不保证迭代顺序，特别是它不保证该顺序恒久不变。

HashSet 是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode 和equals 来完成。
如果元素的HashCode 值相同，才会判断equals 是否为true。
如果元素的hashCode 值不同，不会调用equals

示例：

import java.util.HashSet;import java.util.Set;class Person{String name ;int age;public Person(String name , int age){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//复写hashcode和equals方法。public int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Person other = (Person) obj;if (name == null) {if (other.name != null)return false;} else if (!name.equals(other.name))return false;return true;}@Override//复写tostring方法试打印结果更有意义。public String toString() {return "name=" + name + ": age=" + age + "";}}public class DeMo4 {public static void main(String[] args) {//定义一个hashset集合。Set<Person> s = new HashSet<Person>();//往里面添加元素。s.add(new Person("黑马1", 5));s.add(new Person("黑马2", 6));s.add(new Person("黑马3", 7));System.out.println(s);}}

 

2.TreeSet:有序存放

TreeSet : 底层数据结构是二叉树。可以对Set 集合中的元素进行排序。

TreeSet的排序之自然排序：

TreeSet会调用元素的compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的元素按升序排列.此时需要排序元素的类必须实现Compareble接口,并覆写其int compareTo(Object o)方法;

该方法用于比较对象,若:obj1,compareTo(obj2),返回0,表示两个对象相等,若返回一个正整数,表示obj1大于obj2,若返回一个负整数,表示obj1小于obj2;

对于TreeSet集合而言,判断两个对象相等的标准是:

compareTo()方法比较返回 0;

示例：

import java.util.Set;import java.util.TreeSet;//定义一个类实现comparable接口。class Person implements Comparable{private String name ;private int age;public Person(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//实现compareTo方法。public int compareTo(Object o) {if(o instanceof Person){Person p = (Person) o;int num = this.name.compareTo(((Person) o).name);if(num ==0)return new Integer( age).compareTo(new Integer(age));}return -1;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}}public class DeMo6 {public static void main(String[] args) {//定义treeset集合。Set s = new TreeSet();//存入person对象。实现自然排序方法。s.add(new Person("heima1",140));s.add(new Person("heima2",15));s.add(new Person("heima3",11));s.add(new Person("heima4",63));s.add(new Person("heima5",96));System.out.println(s);}}

 

TreeSet的排序之定制排序

要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,该对象里负责集合元素的排序逻辑;

示例：

import java.util.Comparator;import java.util.Set;import java.util.TreeSet;class Person implements Comparable{private String name ;private int age;public Person(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;}@Overridepublic int compareTo(Object o) {if(o instanceof Person){Person p = (Person) o;int num = this.name.compareTo(((Person) o).name);if(num ==0)return new Integer( age).compareTo(new Integer(age));}return -1;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}}//自定义排序class MyCompare implements Comparator{@Overridepublic int compare(Object o1, Object o2) {// TODO Auto-generated method stubPerson s1 = (Person)o1;Person s2 = (Person)o2;int num = s1.getName().compareTo(s2.getName());if(num==0){return new Integer(s1.getAge()).compareTo(s2.getAge());}return num;}}public class DeMo6 {public static void  main(String[] args) {//定义TreeSet集合往里面传入自定义比较器。实现自定义排序。Set s = new TreeSet(new MyCompare());//添加person对象。s.add(new Person("heima1",140));s.add(new Person("heima2",15));s.add(new Person("heima3",11));s.add(new Person("heima4",63));s.add(new Person("heima5",96));System.out.println(s);}}

 

Map 集合:
 该集合存储键值对，成对存入，保证键的唯一性。
map 将键映射到值的对象。
键值对之间用等号（=）连接。
Map 和Set 很像,Set 集合底层就是使用了Map 集合。
 Map Map ：  Hashtable、 Hashmap、 TreeMap
Hashtable : 底层是哈希表的数据结构， 不可以存入 null键 null 值。线程同步。JDK 1.0，效率低。

HashMap : 底层是哈希表的数据结构 ，并允许使用 nulll 值、 null 键。该集合线程不同步。JDK1.2，效率高。无序 。
TreeMap : 底层是二叉树数据结构。允许使用一个null 键和null 值。线程不同步，可以用于给 map集合中的键进行排序。与集合中的键进行排序。与Set很像 ，其实Set底层 就使用了Map集合。

map集合没有迭代器。

Map集合的输出

方法一：

1.通过entrySet方法变成Set对象

2.调用Set的Iterator方法，此时每个Iterator对象是Map.Entry对象

3.对Map.Entry分离出 key - value

方法二：

1.通过keySet得到Map集合多有key的Set集合

2.调用Set的Iterator方法，此时每个Iterator对象是key值

3.通过Map的getValue(key)得到value值

两种取出方式示例：

import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import java.util.Set;public class DeMo6 {public static void main(String[] args) {Map m = new HashMap();m.put(1, "heima1");m.put(2, "heima2");m.put(3, "heima3");//第一种方法keySetSet s = m.keySet();Iterator it = s.iterator();while(it.hasNext()){int i = (Integer) it.next();System.out.println(i+":"+m.get(i));}//第二种方法entrySetSet s1 = m.entrySet();Iterator it1 = s1.iterator();while(it1.hasNext()){Map.Entry me = (Entry) it1.next();System.out.println(me.getKey()+":"+me.getValue());}}}