集合概述
Collection
- List
  - ArrayList
- Set
  - set接口的实现类，HashSet
  - Iterator-集合的输出
Map
- Map和HashMap
  - 使用迭代器遍历Map
  - Map和 Collection作用

集合概述

◆如果现在要想保存多个对象，肯定使用对象数组完成，但是对象数组本身有一个最大的问题在于其数据的长度，所以后来使用了链表完成了动态对象数组的开发，可是链表的开发难度实在是很大，而且如果一个链表要想真正去使用，只依靠之前所编写的还不够，还需要进行一些代码的调优。
而JDK1.2之后正式引入了类集的概念，类集是一种动态的对象数组，属于各个数据结构的实现类，在整个类集之中主要的组成是一些核心的操作接口：Collection、List、Set、Map、Iterator.

Collection

Collection（单值保存的最大父接口）
所谓的单值保存指的是每一次操作只会保存一个对象，就好像之前的链表程序一样，每一次只保存了一个对象，在 Collection接口之中定义了如下的一些操作方法。

List

List（允许重复的子接口）
List是 Collection的一个最为常用的子接口，首先这个接口的定义如下:

public interface List<E> extends Collection<E>

ArrayList

ArrayList是List子接口使用最多的一个子类，而这个类的定义如下:

public class ArrayList<E>
extends abstractlist<E>
implements List<E>, RandomAccess, Cloneable, Serializable

使用 ArrayList进行List接口的功能验证

public static void main(String[] args) throws Exception {
        //ArrayList<String> all = new ArrayList<String>();也可以这样写
        List<String> all = new ArrayList<String>();
        all.add("Hello");
        all.add("He11o");//内容重复了
        all.add("World");
        for (int x = 0; x < all.size(); x++) {
            String str = all.get(x);// get（）方法只有List接口有
            System.out.print(str + "，");
        }
        ArrayList<Integer> integers = new ArrayList<>();
        ArrayList<Integer> integers2 = new ArrayList<Integer>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        for (int i=0;i<integers.size();i++){
            int n = integers.get(i);
            System.out.println(n);
        }
}

在使用代码的时候可以发现，List集合之中即使存在了重复数据，也可以正常的保存，而且数据保存的顺序就是存入数据的顺序。
eg：

public interface Animal {
    public String getName() ;
    public int getAge();
}

public class Dog implements Animal {
    private String name ;
    private int age ;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public int getAge() {
        return age;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true ;
        }
        if (obj == null) {
            return false ;
        }
        if (!(obj instanceof Dog)) {
            return false ;
        }
        Dog dog = (Dog) obj ;
        if (this.name.equals(dog.name)
                && this.age == dog.age) {
            return true ;
        }
        return false ;
    }
    @Override
    public String toString() {
        return "〖狗的信息〗名字：" + this.name + "，年龄：" + this.age ;
    }
}

public class Tiger implements Animal {
    private String name ;
    private int age ;
    public Tiger(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public int getAge() {
        return age;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true ;
        }
        if (obj == null) {
            return false ;
        }
        if (!(obj instanceof Tiger)) {
            return false ;
        }
        Tiger t = (Tiger) obj ;
        if (this.name.equals(t.name)
                && this.age == t.age) {
            return true ;
        }
        return false ;
    }
    @Override
    public String toString() {
        return "〖老虎的信息〗名字：" + this.name + "，年龄：" + this.age ;
    }
}

import java.util.ArrayList;
import java.util.List;
public class Zoo {
    private List<Animal> animals = new ArrayList<Animal>(); //多个动物
    public void add(Animal ani) {   // 增加动物
        this.animals.add(ani) ; // 增加动物,this可以省略
    }
    public void delete(Animal ani) {
        this.animals.remove(ani) ;  // 需要equals()
    }
    public List<Animal> search(String keyWord) {
        List<Animal> result = new ArrayList<Animal>() ;
        for (int x = 0 ; x < this.animals.size() ; x ++) {
            Animal ani = this.animals.get(x) ;
            if (ani.getName().contains(keyWord)) {  // 满足
                result.add(ani) ;}
        }
        return result ;
    }
}

public class Main {
    public static void main(String[] args) {
        Zoo zoo = new Zoo() ;   // 动物园
        zoo.add(new Dog("花狗",1)) ;
        zoo.add(new Dog("黄狗",1)) ;
        zoo.add(new Dog("黑狗",1)) ;
        zoo.add(new Dog("斑点狗",1)) ;
        zoo.add(new Tiger("斑点虎",2)) ;
        zoo.add(new Tiger("黑虎",2)) ;
        zoo.add(new Tiger("花虎",2)) ;
        zoo.delete(new Dog("斑点狗",1)) ;    // 删除
        List<Animal> result = zoo.search("斑点") ;
        for (int x = 0 ; x < result.size() ; x ++) {
            System.out.println(result.get(x)) ;
        }
    }
}

Set

Set是元素无序并且不可以重复的集合，被称为集
HashSet-哈希集，是Set的一个重要实现类
常用方法也是
1.add addAll
3.size
4.remove
5.removeAll

由于是无序的，所以没有get，set的方法

set接口的实现类，HashSet

 Set<String> all = new HashSet<String>();
        HashSet<String> all2= new HashSet<String>(); 
        all.add("Hello");
        all.add("Hello");//内容重复了,不会被添加进去
        all.add("World");
        System.out.println(all);

Iterator-集合的输出

Set<String> all = new HashSet<String>();
        HashSet<String> all2= new HashSet<String>();
        all.add("Hello");
        all.add("Hello");//内容重复了,不会被添加进去
        all.add("World");
        //遍历
        //获取迭代器
        Iterator<String> iter = all.iterator();
        //循环
        while (iter.hasNext()){//判断是否有下一个元素
            String str = iter.next();
            System.out.println(str+"、");
        }

Map

Map和HashMap

Map提供了一种映射关系，其中的元素是以键值对（key-value）的形式存储的，能够实现根据key快速查找 value
Map中的键值对以 Entry类型的对象实例形式存在
键（key值）不可重复，vaue值可以

Map支持泛型，Map
Map中常用方法，put(key,value)、putA添加元素，get(key)获取元素，remove(key)删除

使用迭代器遍历Map

方法一：

public static void main(String[] args) throws Exception {
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(3,"张三");
        map.put(null,"无名氏");
        map.put(3,"李四");//key重复，value会被新内容覆盖
        map.put(1,"王五");
        map.put(0,"赵六");
        Set< Integer> set=map.keySet();//取得全部的key
        Iterator<Integer>iter = set.iterator();
        while(iter.hasNext()) {
            Integer key = iter.next();
            System.out.println(key + "-->" + map.get(key));
        }
    }

方法二：

public static void main(String[] args) throws Exception {
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(3,"张三");
        map.put(null,"无名氏");
        map.put(3,"李四");//key重复，value会被新内容覆盖
        map.put(1,"王五");
        map.put(0,"赵六");
        Set< Map.Entry<Integer,String>> set=map.entrySet();
        Iterator<Map.Entry<Integer,String>> iter = set.iterator();
        while(iter.hasNext()){
            Map.Entry<Integer,String> me = iter.next();
            System.out.println(me.getKey()+","+me.getValue());
        }
    }

Map和 Collection作用

Collection接口设置完的内容目的是为了输出；
Map接口设置完内容的目的是为了查找。

public static void main(String[] args) throws Exception {
        List<String> all = new ArrayList<String>();
        Collections.addAll(all,"A","B","C");//把A，B，C都添加到集合all中
        System.out.println(all);
        Collections.reverse(all);//逆序
        System.out.println(all);
    }

安卓大师之路

Android安全之java集合