java 集合collection set list map 泛型

集合类的由来：

对象用于封装特有数据，对象多了须要存储，若是对象的个数不肯定，就使用集合容器进行存储。

集合特色：

1，用于存储对象的容器。

2，集合的长度是可变的。

3，集合中不能够存储基本数据类型值。 

集合容器由于内部的数据结构不一样，有多种具体容器。不断的向上抽取，就造成了集合框架。

框架的顶层Collection接口：

|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素能够重复。

|--Set：元素不能重复,无序。

Collection的常见方法：

1，添加。

boolean add(Object obj):

boolean addAll(Collection coll):

2，删除。

boolean remove(object obj):

boolean removeAll(Collection coll);

void clear();

3，判断：

boolean contains(object obj):

boolean containsAll(Colllection coll);

boolean isEmpty():判断集合中是否有元素。 

4，获取：

int size():

Iterator iterator():取出元素的方式：迭代器。

该对象必须依赖于具体容器，由于每个容器的数据结构都不一样。

因此该迭代器对象是在容器中进行内部实现的。

对于使用容器者而言，具体的实现不重要，只要经过容器获取到该实现的迭代器的对象便可，

也就是iterator方法。

Iterator接口就是对全部的Collection容器进行元素取出的公共接口。

5，其余：

boolean retainAll(Collection coll);取交集。

Object[] toArray():将集合转成数组。 

-------------------------------

Collection coll = new ArrayList();

1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
System.out.println(coll);
		
2，删除元素。remove
coll.remove("abc2");//会改变集合的长度 

清空集合.
coll.clear();

使用了Collection中的iterator()方法。 

调用集合中的迭代器方法，是为了获取集合中的迭代器对象。遍历集合数据

Iterator it = coll.iterator();		
while(it.hasNext()){
    System.out.println(it.next());
}

ListIterator it = list.listIterator();//获取列表迭代器对象 它能够实如今迭代过程当中完成对元素的增删改查。Iterator不能够

List: 

|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！

|--ArrayList:内部是数组数据结构，是不一样步的。替代了Vector。查询的速度快。

|--LinkedList:内部是链表数据结构，是不一样步的。增删元素的速度很快。

Arraylist增删改查。

ArrayList:特有的常见方法：有一个共性特色就是均可以操做角标。

1，添加

void add(index,element);

void add(index,collection);

2，删除；

Object remove(index):

3，修改：

Object set(index,element);

4，获取：

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(from,to);

List list = new ArrayList();

添加元素
list.add("abc1");
System.out.println(list);
		
插入元素。		
list.add(1,"abc9");
		
删除元素。
System.out.println("remove:"+list.remove(1));
		
修改元素。
System.out.println("set:"+list.set(1, "abc8"));
		
获取元素。
System.out.println("get:"+list.get(0));
		
获取子列表。
System.out.println("sublist:"+list.subList(1, 2));

LinkedList特有方法:

 addFirst(E o);
 addLast(E o):
 jdk1.6
 offerFirst(E o);
 offetLast(E o);

 getFirst();.//获取但不移除，若是链表为空，抛出NoSuchElementException.
 getLast();
 jdk1.6
 peekFirst();//获取但不移除，若是链表为空，返回null.
 peekLast():
 
 removeFirst();//获取并移除，若是链表为空，抛出NoSuchElementException.
 removeLast();
 jdk1.6
 pollFirst();//获取并移除，若是链表为空，返回null.
 pollLast();

Set:元素不能够重复，是无序。

Set接口中的方法和Collection一致。

|--HashSet: 内部数据结构是哈希表 ，是不一样步的。

如何保证该集合的元素惟一性呢？

是经过对象的hashCode和equals方法来完成对象惟一性的。

若是对象的hashCode值不一样，那么不用判断equals方法，就直接存储到哈希表中。 

若是对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。

若是为true，视为相同元素，不存。若是为false，那么视为不一样元素，就进行存储。

 若是元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。

通常状况下，若是定义的类会产生不少对象，好比人，学生，书，一般都须要覆盖equals，hashCode方法。

创建对象判断是否相同的依据。

 |--linkedHashSet：链式HashSet能够在不重复的状况下，进行链式排序

|--TreeSet:能够对Set集合中的元素进行排序。是不一样步的。 

判断元素惟一性的方式：就是根据比较方法的返回结果是不是0，是0，就是相同元素，不存。 

TreeSet对元素进行排序的方式一：

让元素自身具有比较功能，元就须要实现Comparable接口。覆盖compareTo方法。

若是不要按照对象中具有的天然顺序进行排序。若是对象中不具有天然顺序。怎么办？

可使用TreeSet集合第二种排序方式二：

让集合自身具有比较功能，定义一个类实现Comparator接口，覆盖compare方法。

将该类对象做为参数传递给TreeSet集合的构造函数。

if(this.hashCode()== obj.hashCode() && this.equals(obj))

哈希表肯定元素是否相同

1，判断的是两个元素的哈希值是否相同。

若是相同，在判断两个对象的内容是否相同。

2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。

注意：若是哈希值不一样，是不须要判断equals。

泛型：jdk1.5出现的安全机制。

好处：

1，将运行时期的问题ClassCastException转到了编译时期。

2，避免了强制转换的麻烦。

<>:何时用？当操做的引用数据类型不肯定的时候。就使用<>。将要操做的引用数据类型传入便可，其实<>就是一个用于接收具体引用数据类型的参数范围。

在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型 。

泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。

运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。

为何擦除呢？由于为了兼容运行的类加载器。

泛型的补偿：在运行时，经过获取元素的类型进行转换动做。不用使用者在强制转换了。

泛型的通配符：? 未知类型。 

泛型的限定：

? extends E: 接收E类型或者E的子类型对象。上限

通常存储对象的时候用。好比 添加元素 addAll.

? super E: 接收E类型或者E的父类型对象。 下限。

通常取出对象的时候用。好比比较器。

选择集合的一些技巧：

须要惟一吗？

须要：Set

须要制定顺序： 

须要： TreeSet

不须要：HashSet

可是想要一个和存储一致的顺序(有序):LinkedHashSet

不须要：List

须要频繁增删吗？

须要：LinkedList

不须要：ArrayList

如何记录每个容器的结构和所属体系呢？

看名字！

List

|--ArrayList

|--LinkedList

Set

|--HashSet

|--TreeSet

后缀名就是该集合所属的体系。

前缀名就是该集合的数据结构。

看到array：就要想到数组，就要想到查询快，有角标.

看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法 

看到hash:就要想到哈希表，就要想到惟一性，就要想到元素须要覆盖hashcode方法和equals方法。 

看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。

并且一般这些经常使用的集合容器都是不一样步的。 

Map：键值对

Map：一次添加一对元素。

Collection 一次添加一个元素。

Map也称为双列集合，Collection集合称为单列集合。

其实map集合中存储的就是键值对。 

map集合中必须保证键的惟一性。 

经常使用方法：

1，添加。

value put(key,value):返回前一个和key关联的值，若是没有返回null.

2，删除。

void  clear():清空map集合。

value remove(key):根据指定的key翻出这个键值对。 

3，判断。

boolean containsKey(key):

boolean containsValue(value):

boolean isEmpty();

4，获取。 

value get(key):经过键获取值，若是没有该键返回null。固然能够经过返回null，来判断是否包含指定键。 

int size(): 获取键值对的个数。 

Map经常使用的子类：

|--Hashtable :内部结构是哈希表，是同步的。不容许null做为键，null做为值。

|--Properties：用来存储键值对型的配置文件的信息，能够和IO技术相结合。

|--HashMap : 内部结构是哈希表，不是同步的。容许null做为键，null做为值。

|--TreeMap : 内部结构是二叉树，不是同步的。能够对Map集合中的键进行排序。 

非同步Arraylist加锁方法

List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list.
给非同步的集合加锁。
class MyCollections{
     public static  List synList(List list){ 
     return new MyList(list);
     }
     private class MyList implements List{
         private List list;
         private static final Object lock = new Object();
 
         MyList(List list){ 
             this.list = list; 
         }
         public boolean add(Object obj){
             synchronized(lock)
             {
                 return list.add(obj);
             }
         } 
         public boolean remove(Object obj){
             synchronized(lock)
             {
             return list.remove(obj);
             }
         }
      }
}

list转String[]数组

List list = new ArrayList();
list.add("1");
list.add("2");
final int size =　list.size();
String[] arr = (String[])list.toArray(new String[size]);    //这个就是转换的

string 转 list

String[] arr = new String[] {"1", "2"};

List list = Arrays.asList(arr);