使用数组存放数据的弊端：长度不可变，而集合可以动态的添加值
java集合类不仅可以存储数量不等的多个对象，还可以保存具有映射关系的关联数组
/*
* 1.存储对象可以考虑：①数组 ②集合
* 2.数组存储对象的特点：Student[] stu = new Student[20]; stu[0] = new Student();....
* >弊端：①一旦创建，其长度不可变。②真实的数组存放的对象的个数是不可知。
* 3.集合
* Collection接口
* |------List接口：存储有序的，可以重复的元素
* |------ArrayList（主要的实现类）、LinkedList（对于频繁的插入、删除操作）、Vector（古老的实现类、线程安全的）
* |------Set接口：存储无序的，不可重复的元素
* |------HashSet、LinkedHashSet、TreeSet
* Map接口：存储“键-值”对的数据
* |-----HashMap、LinkedHashMap、TreeMap、Hashtable(子类：Properties)
*/
java集合有Collection和Map集合两种
Collection接口：
Set集合：元素之间无序，不可重复
List集合：元素有序、可以重复
Map集合：具有映射关系的键值对
Collection的继承体系：
Map集合的继承体系
Collection接口：
Collection接口是List、Set、Queue接口的父接口
在java5之前，java集合会丢失容器中所有对象的数据类型，把所有的对象都当做Object对象，java5之后，增加了泛型，java集合可以记住容器中的对象的数据类型
List接口的实现类之一：ArrayList
使用Iterator接口遍历集合中的元素，还可以使用增强for进行遍历
List接口中的元素都有一个整数序号来记录元素的位置，可以根据序号来获取元素
List接口的常用实现类：ArrayList、LinkedList、Vector
ArrayList是List接口的典型实现类，本质上，ArrayList是对象引用的一个变长数组
ArrayList是线程不安全的，而Vector是线程安全的，即使要保证List是安全的，也不用Vector
Arrays.asList()方法返回的List集合是一个固定长度的List集合，不是ArrayList实例，也不是Vector的实例
1 public void collection1() {
2 Collection coll = new ArrayList();
3 // 1.size():返回集合中元素的个数
4 System.out.println(coll.size());
5 // 2.add(Object obj):向集合中添加一个元素
6 coll.add(123);
7 coll.add("AA");
8 coll.add(new Date());
9 coll.add("BB");
10 System.out.println(coll.size());
11 // 3.addAll(Collection coll):将形参coll中包含的所有元素添加到当前集合中
12 Collection coll1 = Arrays.asList(1, 2, 3);
13 coll.addAll(coll1);
14 System.out.println(coll.size());
15 // 查看集合元素
16 System.out.println(coll);
17 // 4.isEmpty():判断集合是否为空
18 System.out.println(coll.isEmpty());
19 // 5.clear():清空集合元素
20 coll.clear();
21 System.out.println(coll.isEmpty());
22 }
1 public void collection2() {
2 Collection coll = new ArrayList();
3 coll.add(123);
4 coll.add(new String("AA"));
5 coll.add(new Date());
6 coll.add("BB");
7 // Person p = new Person("MM",23);
8 coll.add(new Person("MM", 23));
9 System.out.println(coll);
10 // 6.contains(Object obj):判断集合中是否包含指定的obj元素。如果包含，返回true，反之返回false
11 // 判断的依据：根据元素所在的类的equals()方法进行判断
12 // 明确：如果存入集合中的元素是自定义类的对象。要求：自定义类要重写equals()方法！
13 boolean b1 = coll.contains(123);
14 b1 = coll.contains(new String("AA"));
15 System.out.println(b1);
16 boolean b2 = coll.contains(new Person("MM", 23));
17 System.out.println(b2);
18 // 7.containsAll(Collection coll):判断当前集合中是否包含coll中所有的元素
19 Collection coll1 = new ArrayList();
20 coll1.add(123);
21 coll1.add(new String("AA"));
22
23 boolean b3 = coll.containsAll(coll1);
24 System.out.println("#" + b3);
25 coll1.add(456);
26 // 8.retainAll(Collection coll):求当前集合与coll的共有的元素，返回给当前集合
27 coll.retainAll(coll1);
28 System.out.println(coll);
29 // 9.remove(Object obj):删除集合中的obj元素。若删除成功，返回true。否则，返回false
30 boolean b4 = coll.remove("BB");
31 System.out.println(b4);
32
33 }
1 public void collection3() {
2 Collection coll = new ArrayList();
3 coll.add(123);
4 coll.add(new String("AA"));
5 coll.add(new Date());
6 coll.add("BB");
7 coll.add(new Person("MM", 23));
8
9 Collection coll1 = new ArrayList();
10 coll1.add(123);
11 coll1.add(new String("AA"));
12 // 10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素。
13 coll.removeAll(coll1);
14 System.out.println(coll);
15 //11.equals(Object obj):判断集合中的所有元素是否完全相同
16 Collection coll2 = new ArrayList();
17 coll2.add(123);
18 coll2.add(new String("AA1"));
19 System.out.println(coll1.equals(coll2));
20 //12.hashCode():
21 System.out.println(coll.hashCode());
22 System.out.println();
23 //13.toArray() :将集合转化为数组
24 Object[] obj = coll.toArray();
25 for(int i = 0;i < obj.length;i++){
26 System.out.println(obj[i]);
27 }
28 System.out.println();
29 //14.iterator():返回一个Iterator接口实现类的对象,进而实现集合的遍历！
30 Iterator iterator = coll.iterator();
31 //方式一：不用
32 /*System.out.println(iterator.next());
33 System.out.println(iterator.next());
34 System.out.println(iterator.next());*/
35 //方式二：不用
36 // for(int i = 0;i < coll.size();i++){
37 // System.out.println(iterator.next());
38 // }
39 //方式三：使用
40 while(iterator.hasNext()){
41 System.out.println(iterator.next());
42 }
43 }
1 @Test
2 public void test(){
3 String[] str = new String[]{"AA","BB","DD"};
4 for(String s : str){
5 s = "MM";//此处的s是新定义的局部变量，其值的修改不会对str本身造成影响。
6 System.out.println(s);
7 }
8
9 for(int i = 0;i < str.length;i++){
10 System.out.println(str[i]);
11 }
12 }
13 @Test
14 public void testFor2(){
15 String[] str = new String[]{"AA","BB","DD"};
16 for(int i = 0;i < str.length;i++){
17 str[i] = i + "";
18 }
19
20 for(int i = 0;i < str.length;i++){
21 System.out.println(str[i]);
22 }
23 }
List接口的实现类之二：LinkedList
对于频繁的插入、删除元素的操作，建议使用LinkedList，效率较高
List接口的实现类之三：Vector
Vector大多数操作和ArrayList差不多，但是Vector是线程安全的，当插入、删除频繁的时候，使用LinkedList，Vector总是比ArrayList慢
Iterator和ListIterator的区别：
两者都有next()和hasNext()，可以实现向后遍历，但是ListIterator有previous()和hasPrevious()方法，即可以实现向前遍历
ListIterator可以定位当前位置，nextIndex()和previous()可以实现
ListIterator有add()方法，可以向list集合中添加数据
都可以实现删除操作，但是ListIterator可以实现对对象的修改，set()可以实现，Iterator仅能遍历，不能修改
Set集合不允许包含两个相同的元素，如果试图把两个相同的元素加入到同一个Set集合中，则添加操作失败
Set集合判断两个对象是否相等不是使用==，而是使用equals()方法
HashSet使用hash算法进行存储集合中的元素，因此有很好的存取和查找功能
HastSet的一下特点：
不能保证元素的顺序排列
HashSet不是线程安全的
集合元素可以是null
当向HashSet集合中添加一个元素时候，会调用hashCode()方法得到该对象的hashCode值，根据根据该值决定元素的存放位置
HashSet判断两个元素相等的的标准，两个对象的hashCode()是否相等，并且equals()方法是否相等
hashCode(）方法：：
如果元素的equals()方法返回true，但是他们的hashCode()值不同，hashSet会将他们存放在不同的位置，依然可以添加成功
对于存放在集合中的对象，对象的类一定要重写equals()和hashCode()方法，以实现对象的相等原则
Set实现类之二：LinkedHashSet
LinkedHashSset根据元素的hasCode值来决定元素的存储位置，但是它同时使用链表维护次序，这使得元素看起来是有序的
LinkedHashSet的插入性能要低于HashSet，但在迭代访问Set里面的元素是有很好的性能
LinkedHashSet不允许元素的重复
Set实现类之三：TreeSset
TreeSet是SortedSet的实现类，TreeSet可以保证元素处于排序状态
TreeSet两种排序方式：自然排序和定制排序，默认情况下，TreeSet采用自然排序
排序---自然排序
自然排序：TreeSet会调用集合元素的compareTo(Object object)方法来比较元素之间的大小关系，然后将元素按升序排列
如果试图把一个元素添加到TreeSet中，则该对象必须实现Comparable接口
实现Comparable接口必须实现compareTo(Object object)，两个对象即通过这个方法进行比较
Comparable的典型实现
BigDecimal、BigInteger以及所有的数值类型对应的包装类型，按对应的数值大小进行比较
Character：按字符的Unicode值进行比较
Boolean：true对应的包装类实例大于false包装类对应的实例
String：按字符对应的Unicode值进行比较
Date、Time：后面的时间、日期比前面的时间、日期大
向TreeSet中添加一个元素，只有第一个不需要使用compareTo()方法，后面的都要调用该方法
因为只有相同类的两个实例才会比较大小，所以向TreeSet中添加的应该是同一个类的对象
对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是两个对象通过compareTo方法的返回值相等
当需要把一个对象放入TreeSet中，重写对象对应的equals方法时候，应保证该方法与compareTo方法有一致的结果