java集合的使用

java集合的使用

1.集合分为两类，java.util.Colleciotn（直接存储对象应用）java.util.Map（以键值对的形式存储）

2.数组可以理解为一个集合。集合实际上为一个容器，用于存储其他类型的数据。集合同时也是一个对象。

3.集合不能存储基本数据类型，只能够存储引用数据类型。存储基本数据类型是会自动装箱，int转换为Integer等。

4.集合中存储的是对象的引用地址。

5.java中不同的集合底层对应不同的数据结构（数组，双向链表，二叉树，哈希表）

---

一、Collection继承结构（常用集合）

（一）Collection

public interface Collection<E> extends Iterable<E>

Iterable类中有一个iterator()方法，返回一个Iterator对象（常用方法：hasNext（），next（））

Collection的所有子类均可以调用iterator()方法，，返回一个Iterator对象，用于迭代集合中的元素。同时表明所有Collection集合均可迭代

---

（二）List

public interface List<E> extends Colleciton<E>

特点：

1.存储元素有序可重复，存储顺序与迭代顺序一致。

2.存储元素有下标，从0开始递增。

---

（三）Set

public interface Set<E> extends Colleciton<E>

特点：

1.存储元素无序不可重复，存储顺序与迭代顺序不一定一致。

2.存储元素无下标。

3.向Set中存数据实际是存入了Map中的key部分

二、Map继承结构（常用集合）

（一）Map

public interface Map<K,V>

特点：

1.Map与Collection无关系

2.Map集合通过key与value（键值对）的形式进行存储对象引用，key与value均可以是对象引用地址。

三、Collection常用方法

Collection若不指定泛型，则可以存储任意Object的子类对象的引用

1.boolean add（Object e） 向集合中添加元素

2.int size（） 获取集合大小

3.void clear（） 清空元素

4.boolean remove(Object o)   删除某个元素

5.boolean isEmpty(Object o） 判断集合是否为空  底层判断size是否为0

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest01 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();//多态使用，Collection为接口，不能直接创建对象
        //add（）方法  添加元素
        collection.add(100);//自动装箱，实际上放入了一个Integer
        collection.add(0.99);//自动装箱，实际放入了一个Double
        collection.add(new Object());//放入一个Object对象
        //size（）方法 获取集合大小
        int size = collection.size();
        System.out.println(size); //3
        //remove(Object o)  删除某个元素
        collection.remove(100);
        System.out.println(collection.size()); //2
        //clear（）方法 清空集合
        collection.clear();
        System.out.println(collection.size());//0
        //isEmpty()方法 判断集合是否为空
        System.out.println(collection.isEmpty());//true

    }
}

6.boolean contains（Object o） 判断集合中是否存在某个数据

7.Object[] toArray()  将集合转换为一个数组

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest01 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();//多态使用，Collection为接口，不能直接创建对象
        collection.add("张三");
        collection.add("李四");
        collection.add("王五");
        //boolean contains（Object o）  判断集合中是否存在某个数据
        boolean flag1 = collection.contains("张三");
        boolean flag2 = collection.contains("赵六");
        System.out.println("flag1: "+flag1+" flag2: "+flag2);//flag1: true flag2: false
        //Object[] toArray()  将集合转换为一个数组
        Object[] objects = collection.toArray();
        for(Object o:objects){
            System.out.println(o);//张三  李四  王五
        }

    }
}

8.Iterator<E> iterator()

(1)boolean hasNext()  如果集合可以迭代，返回True

(2)Object next()  返回集合下一个迭代的元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest02 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();//多态使用，Collection为接口，不能直接创建对象
        collection.add(100);
        collection.add(3.14);
        collection.add("张三");
        collection.add(new Object());
        //迭代器迭代对于Collection集合通用
        //第一步：获取集合迭代器对象
        Iterator iterator = collection.iterator();
        //第二步：通过迭代器进行迭代遍历
        //boolean hasNext()  如果集合可以迭代，返回True
        //Object next()  返回集合下一个迭代的元素
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);//100 3.14 张三 java.lang.Object@1b6d3586
        }
    }
}

三、List特有方法

（一）常用类

ArrayList

底层为数组，非线程安全。

由于数组中元素在内存空间中地址连续，因此增删元素会导致大量元素位移，效率较低。但是可以通过下标查找元素，效率较高

LinkedList 

底层为双向链表。

由于链表中元素在内存空间中地址不连续，因此增删元素不会导致大量元素位移，效率较高。但是由于不能通过数学表达式计算指定元素的地址，只能从头开始迭代查找元素，效率较低。

Vector

底层为数组，与ArrayList不同的是Vector为线程安全的

（二）构造方法

import java.util.*;

public class ListTest02 {
    public static void main(String[] args) {
        List list01 = new ArrayList();//无参构造，默认初始化容量10
        List list02 = new ArrayList(100);//有参构造，指定初始化容量100
        Collection collection = new HashSet();
        collection.add(1);
        collection.add(2);
        collection.add(3);
        collection.add(4);
        List list03 = new ArrayList(collection);//有参构造,将其他Collectoin集合转换为List集合
    }
}

（三）成员方法

1.void add(int index ,E element)  向指定位置插入元素

2.E get(int index)  根据下标获取元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest01 {
    public static void main(String[] args) {
        List list = new ArrayList();//使用List特有方法，不能用Colleciton声明对象
        list.add("A");//默认向尾部插入元素
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        //void add(int index ,E element)  向指定位置插入元素
        list.add(1,"F");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//A F B C D E
        }
        //E get(int index)  根据下标获取元素
        Object o = list.get(1);
        System.out.println(o);  //F

        //通过下标遍历列表
        for(int i = 0;i< list.size();i++){
            System.out.println(list.get(i));A F B C D E
        }
        //增强for遍历
        for (Object s:list){
            System.out.println(s); //A F B C D E
        }
        //
    }
}

3.int indexOf(Object o)  获取指定对象第一次出现时的索引

4.int lastIndexOf(Object o)  获取指定对象最后一次出现时的索引

5.E remove(int index)  删除指定位置的元素 并且返回删除的元素

6.E set(int index,E element)  修改指定位置的元素 并且返回被修改之前的元素   

import java.util.ArrayList;
import java.util.List;

public class ListTest01 {
    public static void main(String[] args) {
        List list = new ArrayList();//使用List特有方法，不能用Colleciton声明对象
        list.add("A");//默认向尾部插入元素
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        list.add("A");
        list.add("E");
        //int indexOf(Object o)  获取指定对象第一次出现时的索引
        //int lastIndexOf(Object o)  获取指定对象最后一次出现时的索引
        //初始List A B C D E A E
        System.out.println(list.indexOf("A"));  //0
        System.out.println(list.lastIndexOf("A"));  //5
        //E set(int index,E element)  修改指定位置的元素
        Object b = list.set(0, "B");
        System.out.println(b);//A
        for(Object o :list){
            System.out.println(o);//B B C D E A E
        }
        //E remove(int index)  删除指定位置的元素
        Object remove = list.remove(0);
        System.out.println(remove);//B
        for(Object o :list){
            System.out.println(o);//B C D E A E
        }
    }
}

四、Set详解（常用类）

（一）常用类

HashSet（实际使用过成功方法也会自动排序    T^T  可以研究下底层代码）

TreeSet（SortedSet子类）

SortedSet会自动将元素进行排序

对于自定义的类，可以有两种方式

一是：需要实现java.lang.Comparable接口

二是：实现java.lang.Comparator接口，作为一个参数在构造时候进行传递（可使用匿名内部类）

import java.util.HashSet;
import java.util.Set;

public class SetTest01 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("A");
        set.add("B");
        set.add("E");
        set.add("D");
        set.add("H");
        set.add("Z");
        set.add("E");
        set.add("B");
        //传入元素： A B E D H Z E B
        for(String s : set){
            System.out.println(s);//A B D E H Z 去重排序
        }
    }
}

五、Collection常用方法

（一）常用方法

1.V put(K key, V value) 向Map集合中添加键值对

2.int size() 获取Map的大小

3.V get(Object key) 通过key获取value

4.boolean containsKey(Object key) 判断Map是否包括某个key，底层调用equals方法，若自定义类型，需要重写equals方法

5.boolean containsValue(Object value) 判断Map是否包括某个key，底层调用equals方法，若自定义类型，需要重写equals方法

6.void clear() 清空Map集合

7.boolean isEmpty() 判断集合是否为空

import java.util.HashMap;
import java.util.Map;

public class MapTest01 {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer,String> map = new HashMap<Integer, String>();
        //调用put方法向Map集合中增加元素
        //V put(K key, V value) 向Map集合中添加键值对
        map.put(1, "张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        //int size() 获取Map的大小
        int size = map.size();
        System.out.println(size);//4
        //V get(Object key) 通过key获取value
        String string1 = map.get(1);//Map中有key值为1的元素
        System.out.println(string1);//张三
        String string2 = map.get(5);//Map中无key值为null的元素
        System.out.println(string2);//null
        //boolean containsKey(Object key) 判断Map是否包括某个key
        //boolean containsValue(Object value)  判断Map是否包括某个key
        //底层调用equals方法，若自定义类型，需要重写equals方法
        System.out.println(map.containsKey(1));//true
        System.out.println(map.containsKey(5));//false
        System.out.println(map.containsValue("张三"));//true
        System.out.println(map.containsValue("小明"));//false
        //void clear()  清空Map集合
        map.clear();
        System.out.println(map.size());//0
        //boolean isEmpty()  判断集合是否为空
        System.out.println(map.isEmpty());//true
    }
}

8. Collection<V> values() 获取Map的所有value并返回一个collection

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class MapTest01 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        //Collection<V> values()  获取Map的所有value并返回一个collection
        Collection<String> values = map.values();
        for(String s : values){
            System.out.println(s);//张三 李四 王五  赵六
        }
    }
}

（二）遍历Map集合

1.获取所有的key，通过遍历key，遍历value

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest01 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        //Set<K> keySet()  获取Map的所有Key并返回一个set
        Set<Integer> integers = map.keySet();
        for(Integer i :integers){
            System.out.println(i+"   "+map.get(i));
        }
    }
}

 2.调用Set<Map.Entry<K,V>> entrySet() 将Map集合转换为一个Set集合，进行遍历

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest01 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        //Set<Map.Entry<K,V>> entrySet()  将Map集合转换为一个Set集合
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for(Map.Entry<Integer,String> item :entries){
            System.out.println(item.getKey() +" "+item.getValue()+"  就是  "+item);
        }
    }
}

六、Map常用类

（一）HashMap

底层实现为哈希表

（二）HashTable

底层实现为哈希表，线程安全的

（三）Properties

线程安全的，继承与Hashtable，线程安全的，key与value的值必须为字符串

import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) {
        //String getProperty(String key)  通过key获取value
        //Object setProperty(String key, String value)  向集合中放入键值对
        Properties properties = new Properties();
        properties.setProperty("url","jdbc:mysql:/localhost:3306/mydatabase");
        properties.setProperty("name","root");
        properties.setProperty("password","12345");

        System.out.println(properties.getProperty("name"));
    }
}

（四）TreeMap（SortedMap子类）

底层实现为二叉树，key值会自动排序，底层调用comparedto方法

七、Collections工具类

1.Collections.synchronizedCollection（Collection）  可以将非线程安全的转换为线程安全的

   Collections.synchronizedMap（Map）  可以将非线程安全的转换为线程安全的

2.Collections.sort（List c） 对集合进行排序