【常用API】之集合对象

【集合】：

在java的面向对象中，所有的内容都应该是对象类型的。
集合就是存储对象最常用的一种方式。

集合与数组的区别：

数组的长度是固定的，创建的时候就定义了。
集合长度是可变的。

数组只能存取相同类型的数据。
集合可以存取不同类型的数据。

数组可以存取值类型和引用类型。
集合只能存取引用类型。

简单的关系图：

Iterator接口
|
|----Collection接口
| |
|             |----List接口--->【ArrayList】【LinkedList】
| | |
| |                            |---（AbstractList抽象类）--->【Vector】
| |
| |
| |            ----Set接口--->【HashSet】
|
|              ----Map接口--->【HashMap】【Hashtable】

Iterator接口：
用于遍历集合中元素的接口。

Collection接口：
所有集合最大的一个接口 。

具体使用的常用集合对象包括：
Set : HashSet
List: Vector------重量级
List: ArrayList
List: LinkedList
Map : HashMap
Map : Hashtable

所有的集合对象，都是泛型的，当我们实例化，不指定类型的，Java语言默认：Object。

结合对象，都是接口的实现类，允许【推荐】多态实现。

注意：--------------------------------------------

Vector 和 Hashtable：是线程安全的
其他集合对象，线程不安全。

Vector 和 Hashtable：是线程安全的
其他集合对象，线程不安全。

Vector 和 Hashtable：是线程安全的
其他集合对象，线程不安全。
--------------------------------------------------

HashSet：
适合存取数据，但是重复数据不要的操作。
元素没有顺序，只能迭代遍历。

ArrayList：
适合数据读写操作多，不会去修改元素的时候。
它提升读，写，查询的效率。

LinkedList：
适合存入数据，然后按照数据，对元素进行各种操作的时候。
它提供更多的操作方法，提升元素操作效率，但是读写就慢了。

Vector：
他和ArrayList是相同的，只是所有的方法都提供了锁的机制，
因此在多线程中，存取数据的集合对象都使用 Vector

HashMap：
键值对方式存取数据，需要描述性内容存取的时候，选择使用。
它不能迭代的。只能按照key获取值。
它可以直接输出，显示对象格式的数据解构。

Hashtable：
与HashMap一模一样的，只是相同的方法中，Hashtable都添加了锁，
适合用于多线程的时候。

集合的创建的方式，通常采用多态，声明接口，实例化实现类：

List<String> ls = new ArrayList<String>();

                    ls = new LinkedList<String>();

                   ls = new Vector<String>();


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

                                st = new Hashtable<String,String>();

各自实例：

----HashSet集合

package com.xzm.集合;

import java.util.HashSet;

public class _01_HashSet集合 {

    public static void main(String[] args) {
        
        //【线程不安全】
        //HashSet集合类对象  implements Set接口
        //HashSet是无序的，重复的元素不会添加进去的
        //显示数据内容的顺序是按照数据类型大小自动区分的。
        
        //实例化创建集合对象
        //没有指定数据类型，默认都是：Object
        HashSet hs1 = new HashSet();
        hs1.add(123456);
        hs1.add("张三");
        hs1.add(3.1415926);
        
        
        
        //推荐<String>
        HashSet<String> hs = new HashSet<String>();        
        
        //添加元素
        hs.add("师傅");
        hs.add("大师兄");
        hs.add("二师兄");
                
        hs.add("大师兄");//重复内容不添加
        
        hs.add("三师弟");//添加
        
        
        //元素的个数
        System.out.println( "元素个数：" + hs.size() );
        
        
        //判断对象是不是空的：Boolean
        System.out.println( "hs对象是空的嘛？" + hs.isEmpty() );
        
        
        //是否包含指定内容的元素：Boolean
        System.out.println( "有师傅吗？" + hs.contains("师傅") );
        
        
        //溢出对象，返回Boolean，可以直接用于判断
        if( hs.remove("二师兄") ) {
            System.out.println("成功！");
        }
        else {
            System.out.println("失败！");
        }
        
        
        //清空所有元素，保留对象
        hs.clear();
        
        
        
        
        //迭代遍历显示
        for(String str : hs) {
            System.out.println(str);
        }
        

    }

}

----ArrayList集合

package com.xzm.集合;

import java.util.ArrayList;

public class _02_ArrayList集合 {

    public static void main(String[] args) {
        
        //【线程不安全】
        //ArrayList集合 implements List接口
        //是一个有序的列表集合，元素存取类似数组。
        //每一个元素都有索引，值允许重复的
        //【特点】：数据的读写速度块，元素的操作速度慢
        
        
        //创建集合对象
        ArrayList<String> al = new ArrayList<String>();
        
        
        //添加元素
        al.add("张三");
        al.add("李四");
        al.add("王五");
        al.add("张三");
        al.add("张三");
        
        
        //按照索引，获取指定元素的值
        System.out.println( al.get(4) );
        
        //循环和迭代都可以提取
        // 元素个数： .size()
        for(int i=0; i<al.size(); i++) {
            System.out.println( al.get(i) );
        }
        
        
        //判断是否是空的
        System.out.println( "al是空的嘛？" + al.isEmpty() );
        
        //有没有指定元素
        System.out.println( "有田七吗？" + al.contains("田七") );

        //溢出指定元素: 按照指定索引移除的
        //溢出后，返回移除的内容，null就是没有移除
        //后面的元素，都会向前移动一位
        System.out.println("王五移除掉了吗？" + al.remove(2));
        
        //清空所有元素
        al.clear();
        
        
    }

}

----LinkedList集合

package com.xzm.集合;

import java.util.LinkedList;

public class _03_LinkedList集合 {

    public static void main(String[] args) {
        
        //【线程不安全】
        //LinkedList集合  implements  List接口
        //是一个有序的列表集合，元素存取类似数组。
        //每一个元素都有索引，值允许重复的
        //【特点】：元素的操作速度快，存取数据的速度慢。
        
        //实例化对象
        LinkedList<String> ls = new LinkedList<String>();
        
        //添加
        ls.add("abc");
        ls.add("def");
        ls.add("ghi");
        
        
        
        //是否空对象： .isEmpty(), 返回Boolean
        //查找指定对象：.contains(""), 返回Boolean
        //元素个数： .size()
        //按照所以获取： .get()
        
        
        //添加到最后
        ls.add("aaaaa");
        
        //添加到第一个而元素
        ls.addFirst("11111");
        
        //添加到最后
        ls.addLast("22222");
        
        //最后插入一个，第一个，最后一个
        ls.offer("xxxxx");        
        ls.offerFirst("xxxxx");        
        ls.offerLast("xxxxx");
        
        
        //删除第一个或最后一个 返回：溢出的内容
        ls.removeFirst();
        ls.removeLast();
        
        //溢出指定对象，返回boolean
        ls.remove("aaaaa");
        
        
        //迭代
        for(int i=0; i<ls.size(); i++) {
            System.out.println( ls.get(i) );
        }
        
        
        

    }

}

----Vector重量级集合(自带锁，线程安全)

package com.xzm.集合;

import java.util.Vector;

public class _04_Vector重量级集合 {

    public static void main(String[] args) {
        
        // Vector 重量级 集合对象，
        // 里面所有操作方式，都添加了锁，【线程安全的】

        //实例化对象
        Vector<String> vt = new Vector<String>();
        
        
        //添加元素：自带锁，支持多线程，返回Boolean
        vt.add("AAA");
        vt.add("BBB");
        vt.add("CCC");
        
        
        //获取
        System.out.println( vt.get(1) );
        
        //是否空对象： .isEmpty(), 返回Boolean
        //查找指定对象：.contains(""), 返回Boolean
        //元素个数： .size()
        //按照所以获取： .get()
        
        
        //遍历
        for(String str : vt) {
            System.out.println( str );
        }
        
        
    }

}

----HashMap集合

package com.xzm.集合;

import java.util.HashMap;

public class _05_HashMap集合 {

    public static void main(String[] args) {
        
        //【线程不安全】
        //HashMap集合  implements Map接口
        //是按照键值对的方式存取数据的
        
        // key: Integer,String [推荐]
        // value: 任意
        
        
        //创建对象<key,value>
        HashMap<String,Object> hm = new HashMap<String,Object>();
        
        //添加
        hm.put("id", 555);
        hm.put("name", "李四");
        hm.put("age", 25);
        hm.put("height", 181.3);
        
        //值可以重复的，
        //但是，如果key重复，替换原有的值
        hm.put("id", 999); //---->更新id
        
        
        // isEmpty() 是不是空的：Boolean
        // size()    对数
        // clear()   清空，保留对象
        
        //直接输出
        //键值对是没有顺序的
        //对象格式的
        System.out.println( hm );
        
        
        //按照key获取指定的value
        System.out.println( hm.get("name") );
        
        //按照key移除一对：返回value值
        hm.remove("height");
        
        
        //直接输出
        //键值对是没有顺序的
        //对象格式的
        System.out.println( hm );
        
        
    }

}

----Hashtable集合（重量级的，自带锁，线程安全）

package com.xzm.集合;

import java.util.Hashtable;

public class _06_Hashtable集合 {

    public static void main(String[] args) {
        
        //【线程安全的】 
        //与HashMap是一样的
        
        //创建对象
        Hashtable<String,Object> ht = new Hashtable<String,Object>();
        
        //添加
        ht.put("id", 555);
        ht.put("name", "李四");
        ht.put("age", 25);
        ht.put("height", 181.3);
        
        //值可以重复的，
        //但是，如果key重复，替换原有的值
        ht.put("id", 999); //---->更新id
        
        
        // isEmpty() 是不是空的：Boolean
        // size()    对数
        // clear()   清空，保留对象
        
        //直接输出
        //键值对是没有顺序的
        //对象格式的
        System.out.println( ht );
        
        
        //按照key获取指定的value
        System.out.println( ht.get("name") );
        
        //按照key移除一对：返回value值
        ht.remove("height");
        
        
        //直接输出
        //键值对是没有顺序的
        //对象格式的
        System.out.println( ht );
        
        

    }

}