黑马程序员——Collection单列集合

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

（一）集合概述

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

集合与数组辨析
•容器长度
          集合长度可变
          数组长度固定
•存储内容类型
         集合存储引用数据类型
         数组存储任意类型
•是否可存储不同类型数据
        集合可以存储不同类型数据
        数组只能存储相同数据类型

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



分类：

•单列集合Collection
      -List：元素有序、包含重复元素
      -Set：元素无序、不包含重复元素
•双列集合Map：键值映射关系
•其他功能接口
    -迭代器Iterator
    -Comparable与Comparator用于比较元素

（二）Collection

lCollection接口：单列集合的根接口
•主要方法
        -boolean add(E e)
        -boolean remove(Object o)
        -void clear()
        -boolean contains(Object o)
       -boolean isEmpty()
       -int size()
•主要方法2
       -boolean addAll(Collection c)
       -boolean removeAll(Collection c)
       -boolean containsAll(Collection c)
       -boolean retainAll(Collection c)
•返回迭代器方法
      -Iterator<E>iterator()
lIterator接口：单列集合的迭代器。迭代器会像地震搜救队的方式一样去遍历集合中的每一个元素。
•主要方法
-boolean hasNext()
-E next()
•使用固定格式：
•格式一：
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());

}

练习：

/*
* 集合概述：
* 		面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式
* 		JDK为我们提供了一套完整的容器类库，这些容器可以用于存储各种类型的对象，并且长度都是可变的，
* 		我们把这些类统称为集合类，它们都位于java.util包中。
*
* Collection：所有单列集合的接口
* 由于该Collection是一个接口，无法直接创建实例，使用其子类ArrayList对象来创建对象，完成Collection方法的学习。
*
* 1:创建集合对象
* 2:创建元素对象
* 3:将元素放到集合中
* 4:集合遍历(集合获取内容)
*
* boolean add(E e) 添加元素
*/
public class Demo01_Collection {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add("abc");
c.add("bcd");

Person p = new Person("黄盖",58);
c.add(p);
c.add(p);

c.add(true);

System.out.println(c);
}

//之前的数组容器，长度是固定的。添加新的内容算法麻烦
public void method(){
String[] arr = new String[]{"曹操","刘备","孙权","曹丕","刘禅","董卓"};

while(true) {
System.out.println("柳岩找男朋友：");
Random random = new Random();
int randomIndex = random.nextInt(arr.length);

System.out.println("与您配对的是"+arr[randomIndex]);
System.out.println("您是否满意:满意输入1，不满意输入2，将继续匹配");
Scanner sc = new Scanner(System.in);

String next = sc.next();
if(next.equals("1")) {
System.out.println("祝你们幸福");
break;
}else if(next.equals("2")){
continue;
}

}
}
}

/*
*
* 1:创建集合对象
* 2:创建元素对象
* 3:将元素放到集合中
* 4:集合遍历(集合获取内容)
*
* Collection类的其他方法：
* 		boolean add(E e) 添加元素
* 		boolean remove(Object o) 删除元素
*/
public class Demo02_Collection {

public static void main(String[] args) {
method2();
}

//使用集合存储特殊引用类型字符串
public static void method() {
//1:创建集合对象
Collection c = new ArrayList();
//2:创建元素对象
String s = "郭采洁";
String s2 = "郭嘉";
String s3 = "郭靖";
String s4 = "郭达";
String s5 = "郭德纲";
//3：将元素添加到集合中
c.add(s);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);

System.out.println(c);
System.out.println(c.remove("郭达"));
System.out.println(c.remove("郭敬明"));
System.out.println(c);
}

//使用集合存储一般的引用类型 Person
public static void method2() {
//1:创建集合对象
Collection c = new ArrayList();
//2:创建元素对象
Person p = new Person("郭采洁",28);
Person p2 = new Person("郭嘉",32);
Person p3 = new Person("郭靖",18);
Person p4 = new Person("郭达",80);
Person p5 = new Person("郭德纲",44);

//3：将元素添加到集合中
c.add(p);
c.add(p2);
c.add(p3);
c.add(p4);
c.add(p5);
c.add(p4);

System.out.println(c);
//			System.out.println(c.remove(p4));
boolean b = c.remove(new Person("郭达",80));
System.out.println(b);
System.out.println(c.remove(new Person("郭敬明",9)));
System.out.println(c);
}
}

/*
* Collection类的其他方法：
* 		boolean add(E e) 添加元素
* 		boolean remove(Object o) 删除元素
* 		void clear()  清空集合
* 		boolean contains(Object o)  判断集合中是否包含参数元素
* 		boolean isEmpty()  判断集合是否为空
*/
public class Demo03_Collection {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add("黄忠");
c.add("黄月英");
c.add("黄盖");
c.add("黄晓明");

System.out.println(c);
System.out.println("该集合长度为："+c.size());
System.out.println("以上集合是否为空："+c.isEmpty());
System.out.println("判断该集合是否有黄家驹:"+c.contains("黄家驹"));

c.clear();
System.out.println("清空后的集合内容："+c);
System.out.println("该集合长度为："+c.size());
System.out.println("以上集合是否为空："+c.isEmpty());

Collection c2 = new ArrayList();

c2.add(new Person("黄忠",18));
c2.add(new Person("黄月英",18));
c2.add(new Person("黄盖",18));
c2.add(new Person("黄晓明",18));

System.out.println(c2.contains(new Person("黄晓明",18)));
}

}

/*
* Collection的普通方法：
* 		boolean addAll(Collection c)  将参数集合的所有内容，添加到调用方法的集合中
* 		boolean removeAll(Collection c)  移除此 collection 中那些也包含在指定 collection 中的所有元素
* 		boolean containsAll(Collection c)  如果此 collection 包含指定 collection 中的所有元素，则返回 true。
* 		boolean retainAll(Collection c)  仅保留此 collection 中那些也包含在指定 collection 的元素  即求交集
* 		调用该方法后，会将交集的内容赋值给调用方法的集合
*      返回值代表的并不是是否有交集，而是调用方法的集合内容是否改变
*/
public class Demo04_Collection {

public static void main(String[] args) {

Collection<String> c = new ArrayList<Str
ea87
ing>();

c.add("abc");
c.add("bcd");
c.add("cde");

Collection<String> c2 = new ArrayList<String>();

c2.add("134");
c2.add("134e");
c2.add("13234");

c.addAll(c2);
c.addAll(c2);
System.out.println("c1:"+c);
System.out.println("c2:"+c2);

System.out.println("判断C1中是否包含C2中的所有元素"+c.containsAll(c2));

c.removeAll(c2);

System.out.println("c1:"+c);
System.out.println("c2:"+c2);
System.out.println("判断C1中是否包含C2中的所有元素"+c.containsAll(c2));

System.out.println("========================");
Collection<String> c3 = new ArrayList<String>();
c3.add("貂蝉");
c3.add("西施");
c3.add("杨玉环");
c3.add("王昭君");
c3.add("小莲");

Collection<String> c4 = new ArrayList<String>();
c4.add("貂蝉");
c4.add("西施");
c4.add("杨玉环");
c4.add("王昭君");
c4.add("李师师");
c4.add("赵飞燕");

System.out.println(c3);
System.out.println(c3.retainAll(c4));
System.out.println(c3);

}

}

/*
* 1:创建集合对象
* 2:创建元素对象
* 3:将元素放到集合中
* 4:集合遍历(集合获取内容)
*
* Iterator iterator()  返回在此 collection 的元素上进行迭代的迭代器。  即 返回该集合的迭代器对象
*
* Iterator: 用来遍历集合的工具     该类的对象也是容器。在返回的迭代器这个容器中，已经将集合中的内容复制了一份。
* 在该类中提供了方法，供我们取值
* boolean hasNext()  判断是否有写一个元素
* E next()  返回迭代的下一个元素。
*/
public class Demo05_iterator {

public static void main(String[] args) {

//1:创建集合对象
Collection<String> c = new ArrayList<String>();
//2:创建元素对象
//3:将元素放到集合中
c.add("诸葛亮");
c.add("姜维");
c.add("司马懿");
c.add("鲁肃");
c.add("庞统");
c.add("周瑜");
c.add("贾诩");
c.add("郭嘉");
c.add("荀彧");

//4:集合遍历(集合获取内容)
//1)返回迭代器对象
Iterator<String> iterator = c.iterator();
//2)调用迭代器的方法
while(iterator.hasNext()) {
System.out.println(iterator.next());
}

}

}
<div>
</div>

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

主要子类：
      •ArrayList：底层数据结构是数组结构。线程不安全的。所以ArrayList的出现替代了Vector。增删慢,改查快。
      •LinkedList：底层是链表数据结构。线程不安全的，同时对元素的增删操作效率很高。
      •Vector：底层数据结构是数组结构。jdk1.0版本。线程安全的。无论增删还是查询都非常慢.已被ArrayList替代。
特殊方法
      •void add(int index, E element)
      •E remove(int index)
      •E get(int index)
      •E set(int index, E element)
      •List<E> subList(int fromIndex, int toIndex)
      •int indexOf(Object o)
      •int lastIndexOf(Object o)
      •ListIterator<E> listIterator() 注意：用于应对并发修改异常
ListIterator：list特有的迭代器，内含避免并发修改异常的算法。
•主要方法：
      -boolean hasNext()
      -E next()
      -boolean hasPrevious()
      -E previous() 
      -void add(E e)
      -void remove()
      -void set(E e)

/*
* List：有序的Collection集合,并且带索引的。
* 		 可以对插入位置进行精确地控制
*
* List的普通方法：
* 		void add(int index, E element)  指定位置插入指定元素
* 		E remove(int index)  删除指定位置的元素
* 		E get(int index)   获取指定位置的元素
* 		E set(int index,E element) 替换指定位置的元素为新的元素对象
*/
public class Demo01_List {

public static void main(String[] args) {

List list = new ArrayList();

list.add("黄月英");
list.add("黄飞鸿");
list.add("黄世仁");
list.add("黄药师");
list.add("黄继光");

System.out.println(list);

list.add(2,"黄健翔");
list.remove(0);
System.out.println(list.get(0));
list.set(0, "黄圣依");

System.out.println(list);
}

}

LinkedList：与ArrayList不同，LinkedList是方便添加删除的List。
•主要方法：
      -public void addFirst(E e)
      -public void addLast(E e)
      -public E getFirst() 
      -public E getLast()

/*
* LinkedList:  可以对集合一头一尾进行便捷操作的List集合对象
*
* 普通方法
* 		public void addFirst(E e) 插入列表头
* 		public void addLast(E e) 插入列表尾
*
* 		public E getFirst()  获取列表头
* 		public E getLast()  获取列表尾
* */
public class Demo01_LinkedList {

public static void main(String[] args) {

//创建集合对象
LinkedList ll = new LinkedList();
//创建元素对象
//将元素放到集合中
ll.add("刘");
ll.add("张");
ll.add("赵");
ll.add("栾");
ll.add("李");

System.out.println(ll);
ll.addFirst("钱");
System.out.println(ll);
ll.addLast("孙");
System.out.println(ll);

}

}

Vector：安全的List，Vector中提供了一个独特的取出方式，就是枚举Enumeration。此接口Enumeration的功能与Iterator 接口的功能是重复的。
•主要方法：
      -public E elementAt(int index)
      -public E firstElement()
      -public E lastElement()
      -public void setElementAt(E obj, int index)
      -public void removeElementAt(int index)及其他删除
      -public Enumeration<E> elements()

/*
* Vector: 版本老的   速度慢的    安全的  ArrayList
*
* public void addElement(E obj)   添加元素
* public Enumeration elements()   返回该集合的枚举
* Enumeration:枚举   即现阶段，只要认为是一个容器，用于存储元素。 相当于另外一种形式的iterator。
* boolean hasMoreElements()  相当于hasNext
* E nextElement()  相当于next方法
* public E elementAt(int index)  根据索引获取元素对象
*/
public class Demo02_Vector {

public static void main(String[] args) {

Vector vector = new Vector();

vector.add("刘胡兰");
vector.add("董存瑞");
vector.add("江姐");
vector.add("黄继光");

Enumeration elements = vector.elements();

while (elements.hasMoreElements()) {
String name = (String) elements.nextElement();
System.out.println(name);
}
System.out.println("=============");
for (int i=0; i<vector.size(); i++) {
System.out.println(vector.elementAt(i));
}
}

}

（四）Set

Set：单列集合，无序，元素不得重复。与Collection方法一致。
Set方法取出元素只能使用迭代器。
Set主要子类
      •HashSet：线程不安全，存取速度快
           -底层结构为哈希表结构，即区分元素时使用hash值。可以通过hashCode与equals方法的重写，保证元素唯一性。
           -具体代码体现为：先判断哈希值是否相等，再判断equals方法是否返回true。true则为相同元素，存储元素失败，false则为不同元素，存储元素成功。
     •TreeSet：线程不安全，可以对集合中的元素进行排序。
           -通过Comparable让集合内元素具备比较性。
           -通过Comparator让集合具备比较某种类型元素的能力。
           -当Comparator与Comparable冲突时，以Comparator作为标准。
     •LinkedHashSet
           -在HashSet集合的基础上，使迭代顺序可预测

/*
* Set:无序，元素不得重复
* HashSet: 底层结构为哈希表结构的set集合
*/
public class Demo03_Set {

public static void main(String[] args) {

Set set = new HashSet();

set.add("杨千嬅");
set.add("张娜拉");
set.add("容祖儿");
set.add("范冰冰");
set.add("李冰冰");
set.add("李冰冰");

Iterator iterator = set.iterator();

while (iterator.hasNext()) {
String name = (String) iterator.next();
System.out.println(name);
}
}

}

/*
* HashSet判断元素唯一性：
* 		先判断hashCode值，判断新添加进来的元素的hashCode与老元素的hashCode是否相等
* 			如果相等：继续使用新添加元素的equals方法与老元素进行比较
* 				如果equals也相等，说明新元素与老元素相同，不加入集合
* 				如果equals不相等，说明新元素与老元素不相同，加入集合
* 			如果不等：直接判断，两元素不同，接入集合
*/
public class Demo04_HashSet {

public static void main(String[] args) {

Set set = new HashSet();

Cat cat = new Cat("大黄",6);
Cat cat2 = new Cat("旺财",5);
Cat cat3 = new Cat("点点",12);
Cat cat4 = new Cat("登登",5);

set.add(cat);
set.add(cat2);
set.add(cat3);
set.add(cat4);
set.add(new Cat("登登",5));

System.out.println(set);

Iterator iterator = set.iterator();

while (iterator.hasNext()) {
Cat c = (Cat) iterator.next();
System.out.println(c);
}
}
}

/*
* LinkedHashSet：具有可预知迭代顺序的Set
*/
public class Demo05_LinkedHashSet {

public static void main(String[] args) {

LinkedHashSet lhs = new LinkedHashSet();

lhs.add("刘亦菲");
lhs.add("宋承宪");
lhs.add("高圆圆");
lhs.add("黄海波");
lhs.add("黄海波");

Iterator iterator = lhs.iterator();

while (iterator.hasNext()) {
String name = (String) iterator.next();
System.out.println(name);
}
}
}

/*
* 使用TreeSet存储自定义数据类型
*
* Comparable：此接口强行对实现它的每个类的对象进行整体排序。该类有方法可以定义比较规则
* 		int compareTo(T o)  定义比较顺序
*
* 使用TreeSet存储自定义数据类型的方式一：
* 		1：定义元素类，实现Comparable，为了让元素具备比较性
*  	2：重写compareTo方法，定义比较规则，本例中的需求规则是先比较年龄，再比较姓名
*  	3：按照正常的集合使用方法，存储自定义数据类型对象
*
* TreeSet判断元素唯一性的方法，就是元素大小顺序的比较方法。
*/
public class Demo06_TreeSet {

public static void main(String[] args) {

TreeSet ts = new TreeSet();

Person p = new Person("b张飞",18);
Person p2 = new Person("李逵",19);
Person p3 = new Person("包公",20);
Person p4 = new Person("a张骞",18);
Person p5 = new Person("a张骞",18);

ts.add(p);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);

System.out.println(ts);

}

}

public class Person implements Comparable{

private String name;
private int age;

public Person() {
}

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
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}

/*
* 先比较年龄
* 如果年龄相同，再比较姓名
*/
@Override
public int compareTo(Object o) {

Person p = (Person)o;

//this: 新添加的元素
//p: 集合中已经存在的老元素

int result = 0;
//比较年龄
result = this.age - p.age;
//如果年龄相同，再比较姓名
if(result==0) {
result = this.name.compareTo(p.name);
}

return result;
}
}

/*
* 使用TreeSet存储自定义数据类型
*
* TreeSet构造：
* 		public TreeSet(Comparator comparator)  带比较器的构造方法
*
* Comparator： 比较器
* 		强行对某个对象 collection 进行整体排序 的比较函数
*
* 使用TreeSet存储自定义数据类型的方式二：
* 		1：定义比较器类，实现Comparator，为了让集合具备比较某种元素的能力
*  	2：重写compare方法，定义比较规则，本例中的需求规则是先比较姓名，再比较年龄
*  	3：创建比较器对象
*  	4：使用比较器对象创建集合
*  	3：按照正常的集合使用方法，存储自定义数据类型对象
*
* TreeSet判断元素唯一性的方法，就是元素大小顺序的比较方法。
*/
public class Demo07_TreeSet {

public static void main(String[] args) {
//使用匿名内部类方式调用TreeSet带比较器对象的构造方法
TreeSet ts = new TreeSet(new Comparator(){

//自定义比较规则：先比较姓名，再比较年龄
@Override
public int compare(Object o1, Object o2) {

Student s = (Student)o1;
Student s2 = (Student)o2;

//s：新添加的元素
//s2： 集合中已经存在的老元素

int result = 0;
//比较姓名
result = s.getName().compareTo(s2.getName());
//如果姓名相同，再比较年龄
if(result==0) {
result = s.getAge() - s2.getAge();
}

return result;
}}
);

Student p = new Student("b张飞",18);
Student p2 = new Student("d李逵",19);
Student p3 = new Student("c包公",20);
Student p4 = new Student("a张骞",18);
Student p5 = new Student("a张骞",131);

ts.add(p);
ts.add(p2);
ts.add(p3);
ts.add(p4);
ts.add(p5);

System.out.println(ts);
}

}

（五）泛型

泛型：用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数传递。
泛型的优点：
      •提高程序的安全性
      •将运行期问题转移到了编译期
      •省去了类型强转的麻烦
      •优化了程序设计
泛型的使用
      •直接在指定泛型的地方给出明确的数据类型即可
      •在使用泛型后的集合中，迭代器返回时，可以直接返回该种数据类型对象。
      •替代了Object类的“任意化”性，避免了程序员必须预知使用时数据类型的情况。
      •<>里边什么都不写，叫菱形泛型，即前边是什么类型，后边也是什么类型。
泛型的定义
      •泛型类：在类上定义泛型，类中使用该类型
          -格式：class 类名<T>{使用T}
      •泛型方法： 
          -格式：public<T> void method(){使用T}
      •泛型接口：在接口上使用泛型。
          -格式：interface 接口名<T>{}
          -在类实现接口时明确泛型类型
          -在类实现接口时仍不明确泛型类型，在创建对象时明确泛型类型
      •泛型通配符：<?>可匹配任意一种数据类型
      •<?>与<T>的差别
          -通配符修饰的泛型不能直接使用而<T>可以使用
          -通配符修饰相当于声明了一种变量，它可以作为参数在方法中传递，如collection的containsAll方法
          -使用<?>可以完成类型限定,可参见TreeSet
        ? extends E 限定类型上限

        ? super E  限定类型下限

（六）Collections

Collections集合工具类
      •以上为两种工具类，分别对数组或集合进行了常规动作的操作。日常开发中，出现在该两类的功能应该直接调用，而不应手动自己开发。
      •重点关注数组与集合相互转换的方法。
      •重点关注带可变参数与泛型的的方法。
      •注意：当数组转成集合后，长度不可增加。

/*
* Collections：集合工具类
* public static <T> boolean addAll(Collection<? super T> c, T... elements)  为某个集合一次添加多个元素
* Person extends Animal
*
* public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)  二分法查找
* public static <T> int binarySearch(List<? extends T> list,T key, Comparator<? super T> c)  二分法查找
*
* public static void reverse(List<?> list) 翻转集合
* public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
* 即  随机打乱顺序
*/
public class Demo08_Collections {

public static void main(String[] args) {

Collection<String> c = new ArrayList<String>();
Collections.addAll(c, "悟空","悟能","悟净","吴尊","吴奇隆");
System.out.println(c);

Collection<Animal> c2 = new ArrayList<Animal>();

Person p = new Person("吴用",18);
Person p2 = new Person("晁盖",48);
Person p3 = new Person("宋江",38);
Person p4 = new Person("武松",28);

Collections.addAll(c2,p,p2,p3,p4);
System.out.println(c2);

Collections.reverse((List<Animal>)c2);
System.out.println(c2);

Collections.shuffle((List<Animal>)c2);
System.out.println(c2);
}

}