java集合框架、泛型

一、什么是集合框架

数据多了，封装成对象，便于使用，对象多了，怎么办，就要封装成“集合”或者是“数组”（用数组存储对象不方便），于是，出现了集合。数据多了用对象存，对象多了用集合存（当然也可以使用数组存，但是有缺点，不容易操作自己想得到的东西。另外，泛型也属于集合框架！字符串也是对象！）

数组和集合的区别：
1、数组虽然可以存储对象，但是长度是固定不变的，集合的长度是可变的，就像StringBuffer和StringBuilder一样，这是最大的区别！
2、数组中一旦固定了存储的数据类型，就固定了下来，不能更改，但是集合不是的，什么类型的都可以存储。

常用集合层级结构图：
                                                            Collection（“集合”的意思）
      List                       Set（set集合使用迭代器Iterator对元素进行遍历）        Map（将Map集合转换成Set集合然后迭代）
ArrayList   LinkedList       Vector（已经不用）  HashSet      TreeSet              HashMap   TreeMap
这个图是从上到下进行罗列，最上面的范围最大，然后进行分支到第二行，然后分支到第三行。（一二行都是接口！）

List集合的一些小区别：
1、ArrayList：底层使用的是“数组”数据结构，特点是“查询快，增加删除慢”，线程是不同步的。
2、LinkedList：底层使用的是“链表”数据结构，特点是“增加删除快，查询慢”。
3、Vector：底层使用的是“数组”数据结构 ，线程是同步的，但是已经被ArrayList所替代。

ArrayList和LinkedList的区别：
1、当元素中“需要”很多“查询”的时候，“不需要”很多“增加删除”的时候，就用ArrayList。
2、当元素中“需要”很多“增加删除”的时候，“不需要”很多“查询”的时候，就用LinkedList。
注意：但是很多的时候，“增加删除”的操作是很少的，所以很多情况下，都是使用的是：ArrayList，如果实在分不清该用哪个集合的，就用ArrayList集合“使用的是数组数据结构”。

二、常用集合框架

1、ArrayList（值内容存在）

数据结构：

ArrayList的数据结构是线性表。

常用方法：

（1）add()//将指定的元素添加到此列表的尾部。

（2）add(int index,E element)//将指定的元素插入此列表中的指定位置。

（3）addAll(Collection c)//按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。

（4）addAll(int index,Collection c)// 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

（5）clear()//从此 List 集合中移除所有元素。

（6）contains(Object o)//如果此 set 包含指定元素，则返回true。

（7）get(int index)//返回此列表中指定位置上的元素

（8）indexOf(Object o)//返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

（9）isEmpty()//如果此 List集合不包含任何元素，则返回 true。

（10）lastIndexOf(Object o)//返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

（11）remove(int index)//移除此列表中指定位置上的元素。

（12）removeRange(int fromIndex,int toIndex)//移除列表中索引在fromIndex（包括）和toIndex（不包括）之间的所有元素。

（13）set(int index, E element)//用指定的元素替代此列表中指定位置上的元素。

（14）size()//返回此列表中的元素数。

（15）toArray()//按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

 

ArrayList集合遍历三种常用方法：

（1）使用一般for循环进行遍历

for(int i=0;i

    System.out.println(list.get(i));

}

 

(2)使用高级for循环进行遍历

for(String i:list){

    System.out.println(i);

}

 

(3)使用迭代器遍历

Iterator it=list.iterator();

while(it.hasNext){

    System.out.println(it.next());

}

2、LinkedList（值内容存在）
概念：
底层使用的是“链表数据结构”，是基于“链表”的“线性表”数据结构，使用的频率有点少，但是也有一些比较特有的方法。

常用方法：

跟ArrayList集合一样的方法。。。
特有方法：
（1）addFirst() //添加开头元素
（2）addLast() //添加结尾元素
（3）getFirst() //获取开头元素
（4）getLast() //获取结尾元素
（5）removeFirst() //获取开头元素，删除，如果集合中没有元素，就会出现NoSuchElementException异常错误（需要抛异常）
（6）removeLast() //获取结尾元素，删除，如果集合中没有元素，就会出现NoSuchElementException异常错误（需要抛异常）

（7）listIterator(int index)//返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

（8）

3、HashSet（值内容存在）
HashSet集合怎样保证元素唯一性？是通过元素的两个方法：
（1）hashCode和equals来完成。
（2）如果元素的HashCode值相同，才会判断equals是否true（如果元素的HashCode值不相同，是不会调用equals，所以平常开发的时候，一般都会“复写”哈希中的hashCode()方法和equals()方法！对于判断元素是否存在，以及删除等操作，一般的方法是元素的hashCode()方法和equals()方法，这是一个至理名言。Set集合的功能和Collection的功能基本上一致。）

HashSet集合常用方法：

（1）add()//如果此 set 中尚未包含指定元素，则添加指定元素。

（2）clear()//从此 set 中移除所有元素。

（3）contains()//如果此 set 包含指定元素，则返回true。

（4）isEmpty()//如果此 set 不包含任何元素，则返回true。

（5）iterator()//返回对此 set 中元素进行迭代的迭代器。

（6）remove()//如果指定元素存在于此 set 中，则将其移除。

（7）size()//返回此 set 中的元素的数量（set 的容量）。

HashSet集合的优点：
前面自己使用ArrayList的时候，有时候还得判断存入的元素是否相同，因为List以及它的子接口都是“有序”的，所以可以存入“相同的”元素。但是Set以及它的子接口是“无序”的（输入输出都没有顺序），不能存入“相同的”元素，所以根本不用判断元素是否相同，并且相同的元素存入的时候是放在集合的最后面。所以List下的子接口HashSet是不需要判定“元素是否相同”，因为，哈西数值相同，对象相同，是不会存进去的！

4、TreeSet
（1）底层数据结构是“二叉树”，保证元素唯一性的依据是：compareTo方法return 0，TreeSet排序的第一种方法是：让元素自身具备排序功能，元素需要实现Comparable接口，覆盖comparable方法，这种方式也成为元素的“自然顺序”，或者叫做“默认顺序”。

（2）下面是一个“比较器”的例子：

class StrLenComparator implements Comparator{
 public int compare(Object o1,Object o2){
  String s1=(String)o1;
  String s2=(String)o2;
  if(s1.length()>s2.length())
   return 1;
  if(s1.length()

5、HashMap（键值对存在）
总结：
Set集合，都可以使用Iterator迭代器进行对元素的迭代操作，Map集合中没有Iterator迭代器，所以需要将Map集合转换成Set集合（常用entrySet()和keySet()方法进行转换，返回的是set集合），然后再对转换后的Set集合进行迭代，List集合中也有迭代器。

注意：

Map集合使用的是put方法添加“键值对”。

三、常用集合框架区别

List集合：
List集合向其中添加“元素”的时候，是直接添加的元素内容，也可以添加“索引”，但是不能添加“key”值，也就是说不能以“键值对”的形式存在，只有map集合才可以使用“键值对”的形式，直接添加内容或者是添加索引+内容也可以。（因为里面有索引，所以可以存入相同的元素内容，只要索引不同即可，所以这个集合是有序集合）List集合没有直接排序的方式，所以可以使用Collections工具类（collections类是一个静态的工具类，直接使用该类调用其中的方法就可以实现相对应的功能！）进行排序操作。（List集合对其中的元素进行迭代的时候使用的也是Iterator迭代器）。

 

List集合排序方法：
List集合排序使用的是Collections工具类中的sort方法，不管是“自然排序”还是“长度排序”都是可以的。（长度排序一般需要自己手动定义一个自定义的排序类，然后对象传值到Collections类中sort方法中，一个是sort方法可以调用Comparator对集合中的长度进行排序，前提是要对Comparator类中的compare方法进行复写。compare方法是一个int类型的方法，可以返回一个数值，一般使用的是1或者-1，具体代码如下所示：）。

class Comparator1 implements Comparator { //继承的是Comparator接口
 public int compare(String s1, String s2) {  //复写compare方法
  if(s1.length()>s2.length())
   return 1;
  if(s1.length() list=new ArrayList();
  list.add("aa");
  list.add("fdsjakf");
  list.add("fdjk");
  list.add("jkljlk");
  list.add("d");
  list.add("aad");
  sop("原集合的样子是：");
  sop(list);
  sop("自然排序之后的结果是：");
  Collections.sort(list);
  sop(list);
  sop("对长度进行自定义排序之后的结果是：");
  Collections.sort(list, new Comparator1());
  sop(list); 
 }
 public static void main(String[] args) {
  collection();
 }
}

List集合常用方法：
增：
add(index,elemet);
add(index,Collection); //特定索引上添加集合框架
删：
remove(index);
改：
set(index,element);
查：
get(index);
subList(int fromIndex,int toIndex);
listIterator();

List常用集合：
1、ArrayList：底层使用的是“数组”数据结构，特点是“查询快，增加删除慢”，线程是不同步的。
2、LinkedList：底层使用的是“链表”数据结构，特点是“增加删除快，查询慢“（所以用的次数比较少）。
3、Vector：底层使用的是“数组”数据结构，线程是同步的，但是已经被ArrayList替代使用了。

Set集合：
Set集合向其中添加“元素”的时候，直接添加内容即可，没有任何的“索引”和“key”！所以里面只能添加不同的元素，存入相同的元素就会被覆盖！所以里面绝对没有重复的内容！（Set集合使用的是Iterator迭代器对元素进行迭代的遍历！），Set集合默认是有自然输出顺序的，也就是从前往后依次输出。

Set集合特点：
1、List以及下面的“ArrayList”和“LinkedList”是“有序”的，可以存入相同的元素，如果需要判断的时候，还得比较麻烦的进行元素是否相同的判断。（可以存入相同的元素）
2、Set以及下面的“HashSet”和“TreeSet”都是“无序”的，也就是说不可以存入相同的元素，也就不出现需要判断的操作，变得简单，所以视情况而定使用什么集合。（不能存入相同的元素）

Set常用集合：
1、HashSet：数据结构是哈希表，线程是非同步的，保证元素唯一性的原理：判断元素的hashCode值是否相同，如果相同，还会继续判断equals方法，是否为true。
2、TreeSet：可以对Set集合中的元素进行排序。（这个集合有“自动排序”的功能，可以进行自然排序，里面是不会存入相同的元素的）

Map集合：
Map集合是一个以“键值对”存在的集合，里面的所有元素都是以“键值对”的形式存在的，也就是说存入内容的时候，内容必须是以key-value形式存入里面。（Map集合需要转换成Set集合再使用Iterator迭代器对其中的所有元素进行遍历）。

Map常用集合：
（Map下三小弟）
1、TreeMap：向TreeMap集合中添加的元素，有自然排序的特点。将TreeMap集合用keySet()方法或者是entrySet()方法转换成set集合后调用“迭代器”将元素逐个输出。（实际上，只要是Map集合都可以使用上面的方法转换成Set集合然后使用“迭代器”进行遍历输出）TreeMap集合有自动排序的功能。可以“从小到大”或者是“拼音的从大到小”。底层是“二叉树”数据结构，线程也是不同步的，可以用于给Map集合中的“键值”进行排序。
2、HashMap：和TreeMap集合的内容基本一致，底层使用的是”哈希表“数据结构。也可以使用泛型进行数据类型的限定，因为是Map集合，所以使用的是key和value的键值对存在的形式，可以用泛型定义成，意思就是key是int类型的树枝，value是String类型的数值。可以存入null键和null值的，该集合是线程不同步的，将hashtable替代！线程不同步的效率高，但是有点不太安全，没有synchronized安全锁。（HashMap出现在jdk1.2之后）
3、HashTable：底层使用的是”哈希表“数据结构，不可以存入null键和null值的，该集合是线程同步的，线程同步的效率低下，但是比较安全，因为有synchronized安全锁。（HashTable出现在jdk1.0之后）Properties是一个子类，是hashtable集合的子类，也就是说，它具备map集合的特点，而且它里面存储的键值对都是“字符串”！是集合中和io技术相结合的集合容器。该对象的特点是：可以用于“键值对”形势的配置文件，那么在加载数据的时候，需要对数据有固定的格式：键=值。

Map集合元素的遍历：
说明：
Map集合中没有Iterator“迭代器”，也就是说，只能根据“键值”key来获取对应位置上的values值，这样就不是十分的方便了。为了可以使用while或者是for循环将Map集合中的values值“一个一个”输出，提供了两种方法。
1、Map集合调用KeySet()方法，将Map集合转换成Set集合，因为Set集合可以使用Iterator“迭代器”，并且Set集合中可以使用get()方法，利用get()方法返回key值，最后使用Iterator“迭代器”将values值输出。

 Set keyset=map.keySet();//将map.keySet()方法返回的keyset用Integer类型形容，然后进入迭代器中。
  Iterator it=keyset.iterator();
  while(it.hasNext()){
   Integer key=it.next();
   String values=map.get(key);//将values定义成string类型的数据。
   sop("key:"+key+"............values:"+values);//使用map的get方法调取键值进行输出
  }

2、Map集合调用entrySet()方法，将Map集合转换成Set集合，Set集合可以使用Iteratro“迭代器”，并且Set集合中可以使用get()方法，利用get(）方法返回key值，最使用Iterator"迭代器"将values值进行输出。

 Set> keyset=map.entrySet();//其中Map.Entry //泛型就是定义的参数的数据类型，这点毋庸置疑
  Iterator> it=keyset.iterator();
  while(it.hasNext()){
   Map.Entry me=it.next();
   int key=me.getKey();
   String values=map.get(key);
   sop("key:"+key+"........values:"+values);
  }

Map集合常用方法：
1、添加：
put(K key,V value)
putAll(Map m)
2、删除：
clear()
remove(Object key)
3、判断：
containsValue(Object value)
containsKey(Object key)
ieEmpty()
4、获取：
get(Object key)
size()
values() //获取集合中的所有值。

四、迭代器

概念：
什么是迭代器？说白了，迭代就是一个集合的取出元素的方式而已，如果集合中有元素，就取出，如果没有，不取了。好比自己玩的一个“在一个玻璃箱子中放着很多玩具，然后上面一个爪子，抓这些玩具，这个爪子就是iterator（迭代器），里面的玩具就是元素，然后将元素进行一个个的取出，直到去完为止”。

迭代器格式：
1、中国的写作格式
 Iterator it=集合对象.iterator();
 while(it.hasNext){     //hasNext判断的是：如果仍有元素可以迭代，则返回true，所以这个判断挺有水平！
  System.out.println(it.next());   //next()是返回迭代的下一个元素。
 }

2、老外的写作格式（这种写作格式比较常用！）
 for(Iterator it=集合对象.iterator();it.hasNext;){  //这种写作格式比较常用，自己要铭记，实际上是一样的
  System.out.println(it.next());   //只不过是将上面的一句话写到了下面
 }

建议：
由于每一个集合中的数据类型有可能不同，所以取出的方式也有可能不同，所以，取出的方式的定义最好定义在集合的内部，于是，有了后面的总结步骤：将取出的方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素，那么自然而然，取出的方式，自己会定义成内部类的。由于每一个容器的数据结构有可能不同，所以取出的“动作细节”也可能不一样，但是都有共性的内容，那就是“取出”和“判断”，自己可以将这些细节进行抽取。

五、枚举

概念：
枚举是Vector集合框架特有的一种取出方式，枚举也是一种集合中“元素”的取出方式，前面自己学过了“迭代”也是一种“元素”的取出方式，通过书写，感觉“枚举”和“迭代”很相似，其实，“枚举”和“迭代”就是一回事儿，那为什么“枚举”能被“迭代”所替代？因为“枚举”的名字以及方法的名字都比较长，所以被取代了，将会用一个章节讲“枚举”。

六、有序和无序的小区别

1、有序：就是“存入”和“取出”的时候是一样的，怎么存入，怎样取出。
2、无序：就是“存入”和“取出”的时候“不一定”一样了，有可能各种顺序。

七、泛型（反省类&泛型方法）

背景：
jdk1.5之后出现的新特性，用于解决安全问题，是一个安全机制。（generic是一般的意思）

好处：
1、将运行时期出现问题ClassCastException转移到了编译的时期，方便了程序员解决问题，让运行事情问题减少，安全。
2、避免转换的麻烦。

格式：
使用<>来定义要操作的引用的数据类型。在使用java提供的对象的时候，什么时候用到泛型呢？通常在集合框架中很常见，只要见到<>就要定义泛型，其实<>就是用来接收传入数据的类型的，当使用集合的时候，将集合中要存储的数据类型作为参数传递到<>中即可，下面是一个典型的例子：
public static void main(String[] args) {
 ArrayList hs=new ArrayList();
 hs.add("1");
 hs.add("2");
 hs.add("3");
 hs.add("4");
 hs.add("5"); 
 }
以上指定了存入ArrayList集合中的元素都是String类型的数据。所以存入集合中的元素都是String类型的1，2，3，4，5。

反省类&泛型方法区别：
1、“泛型类”的缺点就是一开始就指定了“类中参数的数据类型”，然后让编程人员不能再进行数据输入类型的改变，这是非常痛苦的一件事。
2、所以定义“泛型方法”，就是缩小了“参数类型定义”的范围，在调用“方法”的时候随意输入要传入的参数的数据类型，这样，用户或者是编程人员就可以随意的传入“任意数据类型”了。（所以平常“尽量使用泛型方法”！）

泛型类和泛型方法的一个小演示：

 

/*
定义一个泛型类Generics
*/
class Generics{
 public void shuchu01(String s){
  System.out.println(s);
 }
 public void shuchu02(int i){
  System.out.println(i);
 }
 
}
/*
定义一个类GenericsMethod里面使用的是泛型方法shuchu01
*/
class GenericsMethod{
 public  void shuchu01(LeiXing lx){
  System.out.println(lx);
 }
}
public class GenericsDemo {
 public static void main(String[] args) {
  Generics g=new Generics();
  GenericsMethod gm=new GenericsMethod();
  g.shuchu01("hello");
  g.shuchu02(6);
  gm.shuchu01("你好");
  gm.shuchu01(4);
 }

}

总结：从上面可以看到，定义的泛型类如果想要传入多个不同类型的数值的话，需要定义多个方法，并且在泛型类传值的时候需要多少个类型的参数，就需要定义多少个类型，相当的麻烦，但是反观泛型方法，只需要在方法上定义一个泛型，想传入什么样类型的数值都是可以的！！

泛型限定：
这里普及一个知识点：“通配符”的符号是“？”，在泛型中，如果泛型“<>”中使用的是通配符“？”的话，那么就是指定了该泛型的类型没有被指定！可以使任意类型的数据，只要自己喜欢就行！
1、？ extends E：可以接受E类型或者是E的子类型------“上限”。（这样记：因为子类型是在下面，所以”？“在上面，所以是”上限“）
2、？ super E：可以接受E类型或者是E的父类型------“下限”。（这样记：因为父类型是在上面，所以”？“在下面，所以是”下限“）

接口泛型：
接口可以实现多继承，所以自己编程实现接口的时候，可以将接口定义成“泛型”，然后下面的类“实现”这个接口的时候，也必须声明泛型。

注意：前面自己了解到“集合中的比较器”，如果让“比较器”加了泛型之后，会不会出现“安全提示”呢？答案是：不会出现安全提示的！

 

1、注意：
“泛型”是提供给javac编译器使用的，也就是（java compile）

2、类型信息：
ArrayList al=new ArrayList();
ArrayList all=new ArrayList();
这个编译器将上面的编译完成之后，会将类型信息去掉，所以下面输出的将会是true
System.out.println(al.getClass==all.getClass);

3、详细分析：
ArrayList的意思都是什么？
(1)、整个称为ArrayList泛型类型。
(2)、E称为“类型变量”或“参数化的类型”。
(3)、ArrayList中德Integer称为“类型参数的实例化”或“实际类型参数”。
(4)、ArrayList中<>念作“type of”。
(5)、ArrayList称为原始类型。

4、“java编译器”和“java虚拟机”
List list=new ArrayList();
List list1=new ArrayList();
System.out.println(list.getClass() == list1.getClass());
返回的将是true，说明两个类型list集合是同一份字节码，泛型只是提供给编译器用一下，用过之后那个类型就“释放了”，java虚拟机就不知道了！这个过程叫做“去类型化”

5、参数化类型与原始类型的兼容性
//参数类型化可以引用过一个原始类型的对象，有编译警告
Collection c=new Vector();
//原始类型可以引用一个参数化类型的对象，有编译警告
Collection c1=new Vector();

6、参数化类型不考虑类型参数的继承关系！
Vector