Java中的集合

存储对象可以使用数组或者集合

1/1数组存储对象

1、动态方式（同String）

Student []stu = new Studeng[20];

stu[0] = new Student();

Stu[1] = new Student();

……

2、静态方式（同String）

1/2当我们面向对象编程时，总要处理大量的对象；

 1.处理大量对象，可以使用"数组"存储；

 2.但数组有很多的局限性：

 1).数组的长度一旦确定，后期不能更改；我们程序员可以定义新的数组，但是每次做这样的操作都很费事；

 2).数组在定义时，指定了"数据类型"，那么这个数组就只能装这个数据类型的，不能装其它类型的。

 3.以上的两个局限性，对于我们程序员来说，在操作大量对象时，就非常的不方便。

   所以这时，Java为我们提供了一种"工具"。它类似于"仓库"，可以用来存储大量的"引用"。

   这种"仓库"就是："集合类"；

           特点：

          1).对于我们程序员来说，就像一个"无底洞"，可以装无数的"引用"；我们不用关心"长度"信息；

           2).这些"集合类"可以装任何"引用数据"类型的数据；

Collection接口的基本方法
1、添加
boolean add(E e):将元素e的引用添加到集合中
2、删除
boolean remove(Object o)：将元素从集合中删除
void clear()：清空集合
3、获取
boolean contains(Object o)：查找集合中的元素o，如果有则返回true，否则返回false
boolean isEmpty()：判断集合是否为空，为空返回true，否则返回false
int size()：获取集合的大小

boolean addAll(Collection c)：将指定Collection中的元素都添加到此Collection中
boolean removeAll(Collection c)：删除此Collection中包含在指定Collection中元素
boolean containsAll(Collection c)：如果此Collection中包含指定Collection中所有元素则返回true
boolean retainAll(Collection c)：保留此Collection中也包含在指定Collection中元素

Object[] toArray()：把集合转成数组，可以实现集合的遍历
Iterator iterator()：迭代器，集合的专用遍历方式
4、Colletion的两个子接口：List、Set

Collection子接口——List接口

一、List（list 元素有序，可以重复的集合）
1、ArrayList()（主要实现类）、LinkedList()、Vector()
2、List三个子类的特点
1）ArrayList：数组实现，线程不安全，效率高，使用数组实现，效率比Vector高
2）Vector：数组实现，线程安全，效率低，使用数组实现
3）LinkedList：链表实现，线程不安全，效率高，使用链表实现
3、List特有的方法：
void add(int index,E element);
E remove(int index):
E get(int index)
E set(int index,E element)
ListIterator listIterator():List特有的迭代器，一个可以向前遍历的迭代器。

注意：当我们使用Iterator遍历List时，如果要添加删除元素，如果直接使用list的引用来操作会产生ConcurrentModificationException(并发修改异常)，因为Iterator依赖于List和数组，List的结构发生了改变Iterator并不知道。解决方式：①通过ListIterator来修改，ListIterator继承自Iterator，另外添加了add()，remove（）方法，可以实现元素的添加删除 ②直接使用for循环遍历集合来修改。

当使用ListIterator向前遍历时，一定要先向后遍历
boolean hasPrevious()
E previous()
4、 Iterator和ListIterator的区别：
Iterator是父接口：
Iterator是单向的，只能向下遍历；
Iterator接口成员方法
boolean hasNext()
E next()
5、 ListIterator是Iterator的子接口；
ListIterator是双向的，可以向前遍历；
6、List特有的遍历方式(使用get(int index)方法)：
for(int I = 0;i<list.size,i++){
System.out.println(list.get(i));
}

List实现类——ArrayList

遍历方式
方式一：
使用toArray()将集合转换为数组，使用普通for循环

方式二：
使用toArray()将集合转换为数组，使用增强for循环

方式三：
使用Collection的size()方法和List的get()方法
方式四：
使用接待器（Iterator或者ListIterator）

List实现类——Vector
Vector类（采用数组实现）
1、Vector(类)特有方法：
public void addElement(E obj)：添加一个元素；
public E elementAt(int index):返回指定索引处的引用；
public Enumeration elements()：返回此向量的组件的枚举
capacity()：返回此向量的当前容量

2、遍历
方式一：
for(int i = 0;i < vec.size() ; i++){
//使用Collection的size()方法和List的get方法；
//String str = (String)vec.get(i);
}

方式二：
转换成数组，使用普通for循环
方式三：
转换成数组，使用增强for循环

方式四：
使用迭代器（Iterator或者ListIterator）

方式五：
for(int i = 0;i < vec.size() ; i++){
//使用Vector特有的方法
String str = (String)vec.elementAt(i);
System.out.println(str);
}

List实现类——LinkedList

1、LinkedList类的特有功能：

public void addFirst(E e):将元素e添加到第一个位置上。原位置上的元素依次后移；可以模拟"栈"结构；

public voidaddLast(E e)：将元素e添加到末尾。

public E getFirst()及getLast()：获取第一个元素和最后一个元素；

public E removeFirst()及public E removeLast():删除第一个元素和最后一个元素；

 

2、遍历方式

方式一：

将集合转换为数组，使用普通for循环

 

方式二：

将集合转换为数组，使用增强for循环

 

方式三：

使用接待器（Iterator或者ListIterator）

Collection子接口——Set

1、Set元素是无序的（取出时的顺序与存入时的顺序不一致不可存储重复值），不可重复的集合

2、Set接口是Colletion的子接口，继承了Collection的所有方法 

3、特点

取出时的顺序与存入时的顺序不一致

不可存储重复值（需要重写hashCode()和equals()方法） 

4、要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。进而保证Set中元素的不可重复性！其中hashCode()方法降低哈希值的重复率，equals()方法比较元素的值 

5、HashSet（主要实现类）、LinkedHashSet、TreeSet 

6、向HashSet和LinkedHashSet中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值决定了对象在Set中的存储位置，若此位置没有对象存储，则直接添加进来，若已经有对象存储在此位置，再通过equals（）方法比较这两个对象是否相同，如果相同，后一个对象就不能添加进来，如果不同，则可以添加。 

6/1 重写hashCode()方法：

一般情况下，是将内部成员进行一个int值的累加

对于基本数据类型，尽量转换为int值

对于引用类型，调用它的hashCode()方法（此处的hashCode()方法是String重写的Object的方法）

 

6/2使用哈希表结构的特点：

1、存入时，先计算哈希值，然后存入哈希表；

2、在哈希表中产生了一个哈希值与存储的对象的映射关系

3、在查找时，先通过存储的对象生成一个哈希值，然后从哈希表中通过哈希值获取之前存储的对象

4、综合了数组和链表两种结构，具有数组的两种优势，查询快，增删快 

6/3 哈希表的存储方式：

1、如果hashCode不同则一定存

2、如果hashCode不同，则判断equals()方法，如果equals()不同，则存储 

7、向TreeSet中添加元素时需要实现Comparable接口并重写compareTo方法或者自定义比较器实现Comparator接口并从写compare方法来保证元素的不重复性

Set实现类——HashSet

HashSet保证元素的唯一性：
1.由于HashSet内部使用了"哈希表"，所以它会先产生"哈希值"；
2.通过查看源码，我们知道，判断重复元素的方式：
1.先判断：hashCode是否相同；
2.如果hashCode相同，再判断equals;
3.所以，我们使用HashSet存入自定义对象，如果想使HashSet存储不同的元素，排除掉不同对象，但内部属性完全相同的对象，我们就要在我们的自定义类中重写：hashCode()和equals()

Set实现类——LinkedHashSet

一、特点：
1、内部由链表和哈希表实现；
2、链表：保证顺序；
3、哈希表：保证唯一；


Set实现类——TreeSet
1、TreeSet:内部使用"树"结构存储：
1、先对元素进行比较；
2、对元素进行"排序"；

2、由于要对元素进行排序，所以就需要比较。比较的方式有两种：
1、自然排序
必须实现Comparable接口
重写里面的compareTo()方法
2、使用比较器(定制排序)
①我们的类不用实现任何接口；
②在实例化TreeSet时，使用带Comparator接口的构造方法；
③我们自定义一个类，实现Comparator接口。并重写:compare()方法；

3、向TreeSet中添加的对象必须是同一个类的

4、当一个类没有实现Comparable接口时，如果向TreeSet中添加该类的对象，报ClassCastException

5、当想TreeSet中添加自定义类的对象时，有两种方法：自然排序和定制排序
5/1 自然排序
（1）自然排序：要求自定义类实现Java.lang.Comparable接口，并重写其CompareTo(Object obj)方法，在此方法中指明按照自定义类的那个属性进行排序
（2）为什么要重写compareTo()方法？
①TreeSet的add()方法，内部会自动调用存储对象的compareTo()方法，所以这个方法必须要有。
②compareTo()方法不是Object类中定义的。所以，我们自定义类中是没有这个方法的。
③所以，我们的类，为了满足：TreeSet的add()方法的需要，必须要实现Comparable接口，并重写
compareTo()方法；
注意：对于中文字段使用compareTo()方法进行排序，没有意义。
（3）向TreeSet中添加对象时，首先按照CompareTo(Object obj)进行比较，一旦返回0，虽然只有比较的属
性值相同，但程序会认为这几个对象是相同的，后面的对象将不能添加进去。
（4）自然排序步骤：自定义类实现Java.lang.Comparable接口，并重写其CompareTo(Object obj)方法==>
自定义类中重写equals()和hashCode()方法==>添加对象
5/2 定制排序
1、创建一个实现了Comparator接口的类对象，重写compare()方法，在此compare()方法中，指明是按照某个类的哪个属性排序的，若后添加的元素的该属性值与已添加进的改属性值相同，则后者不能添加进去
2、将此对象作为参数传递给TreeSet的构造器中
3、向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。

可以在实例化TreeSet是在其构造方法中使用匿名内部类，在其内部重写compare()方法
6、遍历集合
方式一：
使用toArray()方法
System.out.println(list);//这不是遍历，是获取一个String
Object[] objArray = list.toArray();
for(int i = 0 ;i < objArray.length ; i++){
String s = (String)objArray[i];
System.out.println(s);
//System.out.println(objArray[i]);//调用Object-->toString()
}
方式二：
使用迭代器：
Iterator iterator():
java.util.Iterator(接口):
成员方法：
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
Object next() 返回迭代的下一个元素。
方式三：
使用增强for循环（基于迭代器的，凡是能用迭代器的都可以使用增强for循环）

Map接口

一、Map接口
1.特点：
1、双列的集合，存储使用"键、值"对；
2、键"是唯一的。
3、当我们存储相同的"键"时，会将新值替换原值；
4、无序的；
2、Map接口是具有映射关系的“key-value对”的集合，其中key不能重复，每个键映射一个值。
3、Map和Collection的区别：
1、Map是双列的，Collection是单列的
2、Map的键唯一,Collection的子体系Set是唯一的：HashSet(唯一)内部使用-->HashMap。所以HashMap对于
重复的"键值"的判断，跟HashSet的判断方式是一样的；
3、Map集合的数据结构只针对键有效，跟值无关；Collection集合的数据结构是针对元素有效

4、HashMap()、LinkedHashMap()、TreeMap()、HashTable()
5、Map接口
|-----HashMap:Map的主要实现类
|-----LinkedHashMap:使用链表维护添加进Map中的顺序。故遍历Map时，是按添加的顺序遍历的。
|-----TreeMap:按照添加进Map中的元素的key的指定属性进行排序。要求：key必须是同一个类的对象！
针对key：自然排序 vs 定制排序
|-----Hashtable:古老的实现类，线程安全，不建议使用。
|----Properties:常用来处理属性文件。键和值都为String类型的

二、常用方法
1、Map的基本方法：
V put(Object key,Object value):向Map中添加一个元素，向Map添加元素时，当存储重重复的键是，是使用
新值替换旧值
V remove(Object key):按照指定的key删除此key-value
void putAll(Map t)
void clear():清空
Object get(Object key)：获取指定key的value值。若无此key，则返回null
boolean containsKey(Object key)
boolean containsValue(Object value):判断Value是否在集合中
boolean isEmpty()盘点集合是否为空
boolean equals(Object obj)
int size():返回集合内的元素的数量

2、Map接口的获取的方法：
V get(Object key)：通过一个key获取一个value
Set<K> keySet():获取所有key，以一个Set返回
Collection<V> values()：获取value，以一个collection返回值
Set<Map.Entry<K,V>>entrySet():获取键值对（用于遍历键值对）

Map实现类——HashMap

1、key是用Set来存放的，不可重复。value是用Collection来存放的，可重复一个key-value对，是一个Entry。所有的
Entry是用Set存放的， 也是不可重复的。
2、向HashMap中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同。若相同 则只能添加进后添加
的那个元素。
3、HashMap:
A.内部使用哈希表结构；
B.验证键的唯一：通过调用"键"对象的hashCode()和equals()。当使用自定义类做"键"，为了维护"键"的唯一性，要在自定义类中重写：hashCode()和equals()方法；
4、遍历
（1）遍历key集
Set set = map.keySet();
for (Object obj : set) {
System.out.println(obj);
}
（2）遍历value集
Collection values = map.values();
Iterator i = values.iterator();
while (i.hasNext()) {
System.out.println(i.next());
}
（3）如何遍历key-value对
// 方式一：
Set set1 = map.keySet();
for (Object obj : set1) {
System.out.println(obj + "----->" + map.get(obj));
}
// 方式二：
Set set2 = map.entrySet();
for (Object obj : set2) {
Map.Entry entry = (Map.Entry) obj;
// System.out.println(entry.getKey() + "---->" + entry.getValue());
System.out.println(entry);
}

Map实现类——LinkedHashMap

1、内部由链表和哈希表实现

2、链表：保证了有序；

      哈希表：保证了唯一；  

注意：Map子类的数据结构，都是应用在"键"上的。

Map实现类——TreeMap

1、内部使用的"树"结构；

2、只对"键"进行排序；

3、TreeMap存储对象时键需要保证唯一性，

HashMap和Hashtable的区别

1、java.util.Hashtabel类

1、内部使用哈希表实现

2、不允许使用NULL键和NULL值

3、线程安全，效率低（同步的）

4、从JDK1.0开始

 

2、java.util.HashMap类

1、内部使用哈希表实现

2、允许使用NULL键和NULL值

3、线程不安全，效率高（不同步）

4、从JDK1.2开始

3、除了非同步和允许使用 null之外，HashMap类与 Hashtable大致相同。

List,Set,Map的联系

List,Set,Map等接口是否都继承了Map接口：不是

Collection(接口)

                |--List(接口):

                        |--ArrayList(类):

                        |--Vector(类):

                        |--LinkedList(类):

                 |--Set(接口):

                        |--HashSet(类):

                         |--TreeSet(类):

                         |--LinkedHashSet(类):

 Map(接口)

        |--HashMap(类):

         |--TreeMap(类):

         |--LinkedHashMap(类):

         |--Hashtable(类);

集合的嵌套

1.一个集合，可以存储任何类型的对象，包括"集合"。
2.所以：一个集合可以存储另一个集合，这就叫：集合的嵌套；
例子：一个班有3名同学，有3个姓名。另一个班有5名同学，有5个姓名；要求：将两个班合并为一个集合打印：
1.定义一个集合，存储第一个班的3名学员；
2.定义一个集合，存储第二个班的5名学员；
3.定义一个大集合，将前面的两个小集合存入；
4.遍历大集合

3、ArrayList嵌套ArrayList
package cn.itcast.demo20_集合的嵌套;
import java.util.ArrayList;

public class Demo {
public static void main(String[] args) {
//1.第一个班的集合
ArrayList<String> class1List = new ArrayList<>();
class1List.add("马云");
class1List.add("马化腾");
class1List.add("雷军");

//2.第二班的集合
ArrayList<String> class2List = new ArrayList<>();
class2List.add("成龙");
class2List.add("甄子丹");
class2List.add("李连杰");
class2List.add("吴京");
class2List.add("洪金宝");

//3.实例化一个大集合
ArrayList<ArrayList<String>> list = new ArrayList<>();
list.add(class1List);
list.add(class2List);

//4.打印大集合
for(ArrayList<String> classList : list){
for(String name : classList){
System.out.println(name);
}
}
}
}

4、HashMap集合嵌套HashMap集合的案例
例子：
有两个班的学员：
----Map<String,Map<String,String>>------------
0616班：
------Map<String,String>------
"it001" "张学友"
"it002" "郭富城"
"it003" "刘德华"

0617班：
------Map<String,String>------
"it101" "刘亦菲"
"it102" "王菲"
"it103" "胡一菲"

package cn.itcast.demo02_集合练习_HashMap集合嵌套HashMap集合的案例;

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

public class Demo {
public static void main(String[] args) {
//1.第一个班的Map
Map<String,String> class1Map = new HashMap<>();
class1Map.put("it001", "张学友");
class1Map.put("it002", "郭富城");
class1Map.put("it003", "刘德华");
//2.第二个班的Map
Map<String,String> class2Map = new HashMap<>();
class2Map.put("it101", "刘亦菲");
class2Map.put("it102", "王菲");
class2Map.put("it103", "胡一菲");
//3.一个大Map，存储两个班的Map集合
Map<String,Map<String,String>> map = new HashMap<>();
map.put("0616班", class1Map);
map.put("0617班", class2Map);

//4.遍历
Set<String> keySet = map.keySet();
for(String classNo : keySet){
System.out.println(classNo);
Map<String,String> m = map.get(classNo);
Set<String> keys = m.keySet();
for(String stuNo : keys){
System.out.println("\t" + stuNo + "\t" + m.get(stuNo));
}

}
}
}


5、HashMap集合嵌套ArrayList集合
HashMap集合嵌套ArrayList集合的案例

例子：
一个班的学员，只记录姓名：
--------Map<String,ArrayList<String>>-------------
0616班
---ArrayList<String>---------
"刘亦菲"
"王菲"
"胡一菲"
0617班
---ArrayList<String>---------
"刘德华"
"张学友"
"郭富城"

package cn.itcast.demo03_集合练习_HashMap集合嵌套ArrayList集合的案例;

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

public class Demo {
public static void main(String[] args) {
//1.第一个班的ArrayList
ArrayList<String> class1List = new ArrayList<>();
class1List.add("刘亦菲");
class1List.add("王菲");
class1List.add("胡一菲");

//2.第二个班的ArrayList
ArrayList<String> class2List = new ArrayList<>();
class2List.add("刘德华");
class2List.add("张学友");
class2List.add("郭富城");

//3.一个Map集合，存储班号，和两个班的ArrayList
Map<String,ArrayList<String>> map = new HashMap<>();
map.put("0616班", class1List);
map.put("0617班", class2List);

//4.遍历
Set<String> keySet = map.keySet();
for(String key : keySet){
System.out.println(key);
ArrayList<String> list = map.get(key);
for(String s : list){
System.out.println("\t" + s);
}
}

}
}

6、ArrayList集合嵌套HashMap集合的案例
package cn.itcast.demo04_集合练习_ArrayList集合嵌套HashMap集合的案例;

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

ArrayList集合嵌套HashMap集合的案例

例子：
-----------ArrayList<Map<String,String>>-----------------
第一个班：
-----Map<String,String>------------
"it001" "刘德华"
"it002" "张学友"
"it003" "郭富城"
第二个班：
-----Map<String,String>------------
"it101" "刘亦菲"
"it102" "王菲"
"it103" "胡一菲"

public class Demo {
public static void main(String[] args) {
//1.第一个班的map
Map<String,String> class1Map = new HashMap<>();
class1Map.put("it001", "刘德华");
class1Map.put("it002", "张学友");
class1Map.put("it003", "郭富城");
//2.第二个班的map
Map<String,String> class2Map = new HashMap<>();
class2Map.put("it101", "刘亦菲");
class2Map.put("it102", "王菲");
class2Map.put("it103", "胡一菲");
//3.一个ArrayList，存储两个班的Map
ArrayList<Map<String,String>> list = new ArrayList<>();
list.add(class1Map);
list.add(class2Map);

//4.遍历ArrayList
for(Map<String,String> map : list){
//遍历map
Set<String> keySet = map.keySet();
for(String key : keySet){
System.out.println(key + "\t" + map.get(key));
}
System.out.println();//打印一个换行符
}

}
}

泛型

一、为什么要使用泛型
1.对于集合类，就其本身而言，是可以添加任何的引用类型。因为它的add()方法的形参是Object类型；但，这样在我
们取出时，会造成很大的麻烦，我们总要向下转型为我们存储的类型；一旦判断失误，就会导致转换失败，会抛出
异常。
2.我们在平时使用集合类时，更多的情况是"只存储一种类型"，所以这时，Java为我们提供了一种方式，可以在定义集合时，就规定好这个集合内能够存储什么类型的数据，一旦定义之后，它的add()方法就只能接受那种类型的数据。这种方式：泛型

二、泛型的语法：
ArrayList<String> list = new ArrayList<String>();
或者：
ArrayList<String> list = new ArrayList<>();(比较常用)
或者：
ArrayList<String> list = new ArrayList();
注意：泛型：只在"编译期"存在。一旦生成class文件后，泛型信息就没有了。
说明，只是用在"编译"时，进行"类型检查"。

三、定义泛型类
1.在类名的后面定义一对<>，里面定义泛型字母：
2.泛型的名称：
1).可以是一个字母(大写、小写)，可以是多个字母；一般都是"一个大写字母"；
T ： Type
K : Key
V : Value
2).可以同时定义多个泛型，每个泛型使用,隔开
3.当其他类使用此类时，可以使用"泛型"，也可以不使用"泛型"，如果不使用"泛型"，那么内部所有使用泛型的位置，全部变为"Object"类型；
例
public class MyArrayList<T> {
public void show(T obj){

}
}

四、定义泛型方法
对于一个方法，可以定义泛型，但如果只定义泛型，而且形参使用泛型，似乎没有什么意义--此方法能接收任何类型数据。但是，如果返回值也定义为T类型，这就表示：这个方法能保证接收某个类型，那么就返回某个类型；
例：
public <T> T show(T t){
System.out.println("t = " + t);
return t;
}

五、定义泛型接口
1、一个接口也可以定义泛型，格式跟"泛型类"相同
例：
public interface IA<T> {
void show(T t);
}
2、当子类实现接口时有三种方法：
2/1 可以继续使用泛型；(常见的情况)
class SubA<T> implements IA<T>{
public void show(T t){
{
}

2/2 可以丢弃泛型；内部的使用泛型的地方全部变为Object类型；
class SubA implements IA{
public void show(Object obj){
}
}
2/3 可以定义为某个具体类型：在接口的名称后，指定具体类型的泛型；
class SubA implements IA<String>{
public void show(String s){
}
}

例：
public class SubA implements IA<String> {
@Override
public void show(T t) {
}

@Override
public void show(Object t) {
}

@Override
public void show(String t) {
Collection c;
}
}

六、泛型通配符
1、<?>:
1).能够指向什么类型的对象？
可以指向具有任何具体类型泛型的集合对象；
ArrayList<?> list1 = new ArrayList<>();//OK的
ArrayList<?> list2 = new ArrayList<String>();//OK的
ArrayList<?> list3 = new ArrayList<Integer>();//OK的
2).可以添加什么类型的引用？
list1:不能添加任何类型；
list2:不能添加任何类型；
list3:不能添加任何类型；
3).取出时，用什么接收？
接收全部使用Object接收；
特点：不能向里面存东西，但可以从里面取东西。这种声明一般用于方法的返回值；
2、<? extends E>:
1).能够指向什么类型的对象？
可以指向具有E或者E的子类类型泛型的集合对象；
ArrayList<? extends B> list4 = new ArrayList<A>();//NO
ArrayList<? extends B> list5 = new ArrayList<B>();//OK
ArrayList<? extends B> list6 = new ArrayList<C>();//OK

public <? extends B> show(){
ArrayList<B> list = new ArrayList<B>();
ArrayList<C> list2 = new ArrayList<C>();
//return list;
return list2;
}
2).可以添加什么类型的引用？
不能存任何类型；
3).取出时，用什么接收？
可以使用E或E的父类类型接收；
特点：不能向里面存东西，只能从里面取东西。这种声明一般用于方法的返回值；表示，这个方法返
回的集合，里面存的可能是E类型，或者E的某个子类类型；
3、<? super E>:
1).能够指向什么类型的对象？
可以指向具有E或者E的"父类"类型泛型的集合对象；
2).可以添加什么类型的引用？
可以添加E或E的子类对象的引用；
3).取出时，用什么接收？
取出时只能用Object接收；
特点：存入的时候是任何E或E的子类对象的引用。取出时，仍然使用Object接收。所以这种声明一般
用于方法的形参

Collections工具类

1、常用方法

java.util.Collections类：对集合操作的工具类。它没有构造方法，是由一些静态方法组成的；

public static <T> voidsort(List<T> list)：根据元素的自然顺序对指定列表按升序进行排序。

注意：形参List<T>中存储的对象一定要是：Comparable的子类类型。因为sort()方法内部使用对象的compareTo()方法进行比较；

publicstatic <T> int binarySearch(List<?> list,T key)

参数：

list -要搜索的列表。

key -要搜索的键。

public static <T> Tmax(Collection<?> coll):根据元素的自然顺序，返回给定collection的最大元素。

public static void reverse(List<?> list):反转指定列表中元素的顺序。

public static void shuffle(List<?> list):打乱集合的顺序；

Properties类

一、java.util.Map:

         |--Hashtable:

                 |--Properties:

                 1.此类不支持泛型；

 

二、Properties特殊功能的使用：

public Object setProperty(Stringkey,String value)-->put(Object key ,Object value)//添加键值对

public String getProperty(Stringkey)-->get(Object key);//返回key所对应的值

public Set<String>stringPropertyNames() -->keySet();//返回键的集合

 

三、Propertis操作配置文件

一般的程序都需要配置文件，记录：用于的一些配置信息；

 

要读取配置文件，使用字符流是可以的。但是由于配置文件有固定的格式：名 =值；

所以Java就提供了一种双列的集合:Properties类，并且内部，添加了一些读取、写入文件的一些方法。

 

操作配置文件的方法：

public void load(Reader reader)：读取。直接存储到本集合内部；

public void store(Writer writer,String comments)：写入。将集合内部的所有键值对，写到配置文件中；

public void store(OutputStream out, String Comments)

 

 

集合的特点和数据结构总结

一、集合的特点

Collection（接口）

|------List（接口）：1、有序；2、可以存储重复元素

|------ArrayList（类）：数组实现，线程不安全，效率高

|------Vector（类）：数组实现，线程安全，效率低

|------LinkedList（类）：链表实现，线程不安全，效率高

|------Set（接口）：1、无序；2、不能存储重复元素；

|------HashSet（类）：哈希表实现。线程不安全，效率高

保证唯一性：使用hashCode()和equals()

|------LinkedHashSet（类）链表、哈希表实现。线程不安全，效率高

|------TreeSet(类)：数组实现。线程不安全，效率高

对元素排序的，要排序就要比较，比较方式：

1、自然排序：

①我们的类要实现Comparable接口

②重写compare方法

2、比较器排序

①我们的类不需要实现任何接口

②自定义一个比较器，实现Comparator接口，重写compare（）方法

③实例化TreeSet时，传递自定义比较器的对象

Map(接口)

1.双列集合，使用"键、值对"存储；

 

|------HashMap(类):哈希表实现。线程不安全的，效率高；

保证"键"的唯一性，同HashSet

|------TreeMap(类):树实现。线程不安全的，效率高；

对"键"的排序，同TreeSet

|------LinkedHashMap(类);链表、哈希表实现。线程不安全的，效率高；

|------Hashtable(类):哈希表实现。线程安全的，效率低；

 

 

 

 

二、数据结构

1、数组：查询快、增删慢

2、链表：查询慢、增删快

3、栈：后进先出

4、队列：先进先出

5、哈希表：综合了数组和链表的优点。查询、增、删都很快；

6、树：第一个存储的作为"根节点"，再存储其它元素时，跟每个元素依次比较，小的：存到左边，

      大的：存到右边。相等的：不存；

如何选择使用哪种集合

1、需要单列还是双列

|------单列：使用Collection

|------有序：使用list

|------经常查询，但不经常修改：使用ArrayList(单线程、快)，Vector(多线程、慢)

|------经常会修改：使用LinkedList

|------无序：使用Set

|------不需要排序：HashSet(无序的)、LinkedHashSet(有序的)

|------需要排序：TreeSet

|------双列：使用Map

|------不需要排序：使用HashMap、linkedHashMap

|------需要排序：TreeMap

多种集合的遍历方式

1、Collection

1、toArray()

2、迭代器

3、增强for(常用)

 

|------List

4、特有的遍历方式：使用Collection的size()和List的get(intindex)（常用）

5、Vector特有的遍历方式：使用elementAt()方法

|------Set

没有特有的遍历方式

 

2、Map

1、keySet()：遍历set<键>

2、entrySet():遍历Set<Map.Entry>

 

3、常用的遍历方式

增强for循环：不使用循环变量

普通for循环：使用循环变量