Java之集合初探（一）

一、集合概述、区别

集合是一种容器，数组也是一种容器

在Java编程中，装各种各样的对象（引用类型）的叫做容器。

为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

数组和集合类同是容器，有何不同？

A:长度区别
　　数组的长度固定
　　集合长度可变
B:内容不同
　　数组存储的是同一种类型的元素
　　而集合可以存储不同类型的元素
C:元素的数据类型问题
　　数组可以存储基本数据类型，也可以存储引用数据类型
　　集合只能存储引用类型

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

如果我们用数组来制作一个简单的容器，可以存储数据改变大小

//自定义的容器

package util;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Myarr {
    private Object[] obj;
    private int size;//代表数组中有效的数量

    public Myarr(){
        obj=new Object[10];
        size=0;
    }

    public int Size(){
        return this.size;
    }

    public boolean add(Object o){//可以添加各种类型
        //因为数组的长度是固定的，首先判断装满否

        if(size<obj.length){//有效长度小于数组长度，没装满
            obj[size]=o;
        }else{
            Object[] os=Arrays.copyOf(obj, size+1);
            os[size]=o;
            obj=os;
        }
        size++;
        if(size==obj.length){
            return true;
        }
        return false;
    }

    public String toString(){
        Object[] onew=new Object[size];
        for(int i=0;i<size;i++){
            onew[i]=obj[i];
        }
        return Arrays.toString(onew);
    }
}

//主方法
package test;

import util.Myarr;

public class Test {
    public static void main(String[] args) {
                // 添加小于10的情况
        Myarr ma=new Myarr();
        ma.add(56);
        ma.add("so");
        ma.add(5.653);
        System.out.println(ma.Size());
        System.out.println(ma);
                //添加大于10的情况
        Myarr ma1=new Myarr();
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        System.out.println(ma1.Size());
        System.out.println(ma1);
    }
}

二、不同的集合类

集合是存储多个元的，由于存储多个元素我们也是有不同需求的：比如，我要这多个元素中不能有相同的元素，再比如，我要这多个元素按照某种规则排序一下。针对不同的需求，Java就提供了不同的集合类。 这多个集合类的数据结构不同,结构不同不重要的，重要的是你要能够存储东西，并且还要能够使用这些东西，比如说判断，获取等。 既然这样，那么，这多个集合类是有共性的内容的，我们把这些集合类的共性内容不断的向上提取，最终就能形成集合的继承体系结构

Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。

Collection
　　List---(有顺序, 可以重复)---下标

　　　　（这里判断重复的标准是可以互相equals(引用类型)）

　　　　LinkedList(基于链表)---(改快,查慢)

　　　　*ArrayList(基于数组)---(改慢,查快)

　　Set---(没有顺序, 不可以重复)

　　　　*HashSet(基于hash码表)(必须重写hashCode()方法)

　　　　TreeSet(基于二叉树---数据结构)

Map(以键值对的方式存在)(键不能重复)

　　Map<Person.hashCode(), int>

　　*HashMap

　　TreeMap

Comparable(一个方法(comparaTo))

Iterator(循环遍历, 3个方法)

　　返回值boolean hasNext()集合里有没有下一个

　　返回值Object next()返回下一个对象的实例

　　remove()

　　大致如下

　　while(hasNext()) {
　　　　next()
　　}

注意：

接口不可以直接new实例化，new后面只能是他的子类，Collection里没有方法体

Collection的功能概述：

1：添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素
2:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
3:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
boolean isEmpty()：判断集合是否为空
4:获取功能
Iterator<E> iterator()(重点)
5:长度功能
int size():元素的个数
面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
6:交集功能
boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?
7：把集合转换为数组
Object[] toArray()

Java中集合主要分为三类

• Set（集）
• List（列表）
• Map（映射）

List接口（列表）:

List的特征是其元素以线性方式存储，集合中可以存放重复对象。 

List接口主要实现类包括：

• ArrayList() : 代表长度可以改变得数组。可以对元素进行随机的访问，向ArrayList()中插入与删除元素的速度慢。 API中介绍初始容量为10。
• LinkedList(): 在实现中采用链表数据结构。插入和删除速度快，访问速度慢。

对于List的随机访问来说，就是只随机来检索位于特定位置的元素。 List 的 get(int index) 方法放回集合中由参数index指定的索引位置的对象，下标从“0” 开始。最基本的两种检索集合中的所有对象的方法：

　　1： for循环和get()方法：

　　2： 使用 迭代器（Iterator）:

List主要分：

List：最大的特点是有序，它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。

ArrayList：由数组实现。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历 ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。

LinkedList ：对顺序访问进行了优化，向List中间插入与删除的占用并不大。随机访问则相对较慢。(使用ArrayList代替。)还具有下列方法：addFirst(), addLast(),getFirst(),getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

接口的常用方法

add()   添加

remove()    移除

import java.util.ArrayList;
import java.util.Collection;
public class TestColle {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection c=new ArrayList();
        c.add(1);
        c.add("hello");
        c.add(new Person());
        System.out.println(c);

        c.remove(1);
        c.remove("hello");
        c.remove(new Person());//用new新创建的equls时找不到原来的new 创建的所以移除不了
        System.out.println(c.size());
        System.out.println(c);
    }
}
class Person{
    @Override
    public String toString() {
        return "Person [hi]";
    }
}

List接口其他常用方法

 package until;

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

 public class Test1 {
     public static void main(String[] args) {
         List li=new ArrayList();
         List lis=new ArrayList();

         for(int i=0;i<5;i++){
             li.add("string"+i);
             if(i%2==0){
                 lis.add("string"+i);
             }
         }
         System.out.println(li);
         System.out.println(li.get(2));//获取该索引位置的值
         System.out.println(li.set(1, "Hello"));//将某个索引的值设置为另一个对象，然后将原来的索引的值返回
         System.out.println(li);
         System.out.println(li.remove(4));//删除对象并将删除的对象返回
         System.out.println(li.indexOf("string0"));//返回该对象第一次出现的位置
         System.out.println(li.lastIndexOf("string0"));//返回该对象最后一次出现的位置
         System.out.println(li.retainAll(lis));//取二者的交集赋给第一个集合，如果两个第一个集合改变了返回true
         System.out.println(li);
     }
 }

Map(映射):

Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口 从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。

Map的执行效率相对低下。

Map包含：

Map : 维护“键值对”的关联性，使你可以通过“键”查找“值”

HashMap：Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。

LinkedHashMap： 类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。

TreeMap ： 基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。

WeakHashMao ：弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。

IdentifyHashMap： : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。

Map接口常用方法

package until;
import java.util.HashMap;
import java.util.Map;

public class Test1 {
    public static void main(String[] args) {
        Map map = new HashMap();
        for (int i = 0; i < 5; i++) {
            map.put(i, new Person("name" + i));//循环添加
        }
        System.out.println(map);
        map.put(5, new Person("Xman"));//再次添加
        System.out.println(map);
        map.put(1, new Person("NewMan"));//在已有的键上添加替换
        System.out.println(map);
        System.out.println(map.get(5));//获取指定的键的值
        System.out.println(map.remove(0));//删除键的值并返回值
        System.out.println(map.remove(0, "na"));//删除键值，成功返回true
        System.out.println(map.containsKey(4));//判断是否包含该键
        System.out.println(map.containsValue(new Person("name0")));//判断是否有该值
        System.out.println(map.size());//返回有多少对
        System.out.println(map.isEmpty());//返回是否空
        map.clear();//清空
        System.out.println(map);
        Map map2=new HashMap();
        map2.putAll(map);//添加另一个map集合
        System.out.println(map2);
    }
}

class Person{
    String name;
    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "P ["+ name + "]";
    }
}

Set接口

Set是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。 Set接口主要实现了两个实现类：

　　HashSet： HashSet类按照哈希算法来存取集合中的对象，存取速度比较快

　　TreeSet ：TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。

Set具有与Collection完全一样的接口，因此没有任何额外的功能。(这是继承与多态思想的典型应用：表现不同的行为。)Set不保存重复的元素。 存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。

HashSet：为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。

TreeSet： 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。

LinkedHashSet：具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

 

三、总结与注意

Collection 和 Map 的区别

容器内每个为之所存储的元素个数不同。

Collection类型者，每个位置只有一个元素。

Map类型者，键值对，类似于数据库。

注意：

1.Collection、List、Set、Map都是接口，不能实例化。继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class，这些才可被实例化。

2. 如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。

 

3. 在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。

4. 容器类仅能持有对象引用（指向对象的指针），而不是将对象信息copy一份至数列某位置。一旦将对象置入容器内，便损失了该对象的型别信息。

5. 尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

6、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。

7、List，可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个，get(0)...。(add/get)

8、Map用 put(k,v) / get(k)，还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。HashMap会利用对象的hashCode来快速找到key。

9、Map中元素，可以将key序列、value序列单独抽取出来。

使用keySet()抽取key序列，将map中的所有keys生成一个Set。

使用values()抽取value序列，将map中的所有values生成一个Collection。

因为，key总是独一无二的，value允许重复。