Java API(二)

1.集合

    boolean add(E e)
    boolean remove(Object o)
    void clear()
    boolean contains(Object o)
    boolean isEmpty()
    int size()
    toArray()

    boolean addAll(Collection c)
    boolean removeAll(Collection c)
    boolean containsAll(Collection c)
    boolean retainAll(Collection c)

1.1迭代器概述

        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        Iterator it = c.iterator();                     //获取迭代器的引用
        while(it.hasNext()) {                           //集合中的迭代方法(遍历)
            System.out.println(it.next());
        }

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,
迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,
第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

2.List集合

* void add(int index,E element)
* E remove(int index)
* E get(int index)
* E set(int index,E element)
* 迭代器修改元素ListIterator的特有功能add

A:List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
Vector相对ArrayList查询慢(线程安全的)
Vector相对LinkedList增删慢(数组结构)
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

Vector和ArrayList的区别
Vector是线程安全的,效率低
ArrayList是线程不安全的,效率高
共同点:都是数组实现的
ArrayList和LinkedList的区别
ArrayList底层是数组结果,查询和修改快
LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
共同点:都是线程不安全的
* B:List有三个儿子，我们到底使用谁呢?
查询多用ArrayList
增删多用LinkedList
如果都多ArrayList

LinkedList类特有功能标题

* public void addFirst(E e)及addLast(E e)
* public E getFirst()及getLast()
* public E removeFirst()及public E removeLast()
* public E get(int index);

3.Set集合

Set集合,无索引,不可以重复,无序(存取不一致)

* HashSet
* LinkedHashSet
 * 底层是链表实现的,是set集合中唯一一个能保证怎么存就怎么取的集合对象
 * 因为是HashSet的子类,所以也是保证元素唯一的,与HashSet的原理一样
 *  TreeSet集合是用来对象元素进行排序的,同样他也可以保证元素的唯一
 * 当compareTo方法返回0的时候集合中只有一个元素
 * 当compareTo方法返回正数的时候集合会怎么存就怎么取
 * 当compareTo方法返回负数的时候集合会倒序存储

4.Map接口

* Map是双列的,Collection是单列的
* Map的键唯一,Collection的子体系Set是唯一的
* Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效


* Map集合的功能概述
* a:添加功能
* V put(K key,V value):添加元素。
* 如果键是第一次存储，就直接存储元素，返回null
* 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
* b:删除功能
* void clear():移除所有的键值对元素
* V remove(Object key)：根据键删除键值对元素，并把值返回
* c:判断功能
* boolean containsKey(Object key)：判断集合是否包含指定的键
* boolean containsValue(Object value):判断集合是否包含指定的值
* boolean isEmpty()：判断集合是否为空
* d:获取功能
* Set<Map.Entry<K,V>> entrySet():
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合
* e:长度功能
* int size()：返回集合中的键值对的个数

HashMap TreeMap LinkedHashMap底层是链表实现的可以保证怎么存就怎么取

Map集合的遍历之键找值

            HashMap<String, Integer> hm = new HashMap<>();
            hm.put("张三", 23);
            hm.put("李四", 24);
            hm.put("王五", 25);
            hm.put("赵六", 26);

            /*Set<String> keySet = hm.keySet();         //获取集合中所有的键
            Iterator<String> it = keySet.iterator();    //获取迭代器
            while(it.hasNext()) {                       //判断单列集合中是否有元素
                String key = it.next();                 //获取集合中的每一个元素,其实就是双列集合中的键
                Integer value = hm.get(key);            //根据键获取值
                System.out.println(key + "=" + value);  //打印键值对
            }*/

            for(String key : hm.keySet()) {             //增强for循环迭代双列集合第一种方式
                System.out.println(key + "=" + hm.get(key));
            }

Map集合的遍历之键值对对象找键和值

            HashMap<String, Integer> hm = new HashMap<>();
            hm.put("张三", 23);
            hm.put("李四", 24);
            hm.put("王五", 25);
            hm.put("赵六", 26);
            /*Set<Map.Entry<String, Integer>> entrySet = hm.entrySet(); //获取所有的键值对象的集合
            Iterator<Entry<String, Integer>> it = entrySet.iterator();//获取迭代器
            while(it.hasNext()) {
                Entry<String, Integer> en = it.next();              //获取键值对对象
                String key = en.getKey();                               //根据键值对对象获取键
                Integer value = en.getValue();                          //根据键值对对象获取值
                System.out.println(key + "=" + value);
            }*/

            for(Entry<String,Integer> en : hm.entrySet()) {
                System.out.println(en.getKey() + "=" + en.getValue());
            }

5.泛型

<>中放的必须是引用数据类型 ；前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
public class 类名<泛型类型1,…>
public <泛型类型> 返回类型 方法名(泛型类型 变量名)
public interface 接口名<泛型类型>

* A:泛型通配符<?>
* 任意类型，如果没有明确，那么就是Object以及任意的Java类了
* B:? extends E
* 向下限定，E及其子类
* C:? super E
* 向上限定，E及其父类

增强for

for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素

* 普通for循环,可以删除,但是索引要--
* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
* 增强for循环不能删除
* Arrays工具类的asList()方法的使用
* Collection中toArray(T[] a)泛型版的集合转数组

6.Collections工具类

    public static <T> void sort(List<T> list)
    public static <T> int binarySearch(List<?> list,T key)
    public static <T> T max(Collection<?> coll)
    public static void reverse(List<?> list)
    public static void shuffle(List<?> list)

7.异常

异常就是Java程序在运行过程中出现的错误。

异常的继承体系
    * Throwable
        * Error 
        * Exception
            * RuntimeException

异常处理的两种方式
* a:try…catch…finally
* b:throws

* Throwable的几个常见方法
    * a:getMessage()
        * 获取异常信息，返回字符串。
    * b:toString()
        * 获取异常类名和异常信息，返回字符串。
    * c:printStackTrace()
        * 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。