1、集合：
集合是java中提供的一种容器，可以用来存储多个数据。
集合和数组的区别：数组的长度是固定的。集合的长度是可变的。集合中存储的元素必须是引用类型数据
（1）ArrayList 集合存储元素并遍历
练习一：ArrayList集合存储5个int类型元素
import java.util.ArrayList; public class Demo01 { public static void main(String[] args) { ArrayList<Integer> list=new ArrayList<Integer>(); list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); for(int i=0;i<list.size();i++){ System.out.println(list.get(i)); } } }
练习二：ArrayList集合存储5个Person类型元素
package demo03; public class Person { String name; public Person(String name) {//================================构造方法传参 super(); this.name = name; } @Override public String toString() {//==================================重写toString方法 return name ; } }
package demo03; import java.util.ArrayList; public class Demo01 { public static void main(String[] args) { ArrayList<Person> list=new ArrayList<Person>(); list.add(new Person("张三")); list.add(new Person("李四")); list.add(new Person("王五")); list.add(new Person("赵六")); list.add(new Person("孙七")); for(int i=0;i<list.size();i++){ System.out.print(list.get(i)+" "); } } }
（2）ArrayList集合的继承实现关系
ArrayList类继承了抽象类AbstractList同时实现接口List，而List接口又继承了Collection接口。Collection接口为最顶层集合接口了
public interface List extends Collection {//==========List接口继承了Collection接口 } public class ArrayList extends AbstractList implements List{ }
我们在使用ArrayList类时，该类已经把所有抽象方法进行了重写。那么，实现Collection接口的所有子类都会进行方法重写。
Collection接口常用的子接口有：List接口、Set接口
List接口常用的子类有：ArrayList类、LinkedList类
Set接口常用的子类有：HashSet类、LinkedHashSet类
图shi:
Collection接口是集合中的顶层接口,因此他中的所有的子类功能都可以使用。
一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
ArrayList是允许重复和有序的，set是不许重复和无序的
Collection 表示一组对象，这些对象也称为 collection 的元素。
Collection接口的基本方法：
add()：bollean类型，确保此Collection包含指定的元素，基本无法使用，
clear（）：移除此Collection中的所有的元素
contains()：boolean类型，如果此Collection包含指定的元素，包含则返回true，反之返回false
size（）：int类型，返回此Collection中的元素数
toArray（）：将集合转成数组
这些基本方法都得通过方法重写后才能使用，要不没有意义，都是通过new ArrayList重写
格式1：
Collection<String> col=new ArrayList<String>();String代表了元素类型，col是变量名：这样创建的集合，只能存储<>中指定的元素类型，该方式为常用方式
格式2：
Collection col=new ArrayList（）；col是变量名，这样创建的集合，集合的元素类型默认为Object类型，即任何类型的元素都可以存储。
Collection接口中的方法的演示：
package demo06Collectionmethod; import java.util.ArrayList; import java.util.Collection; public class Demo01 { public static void main(String[] args) { Collection col=new ArrayList(); col.add("abc");//add()方法是重写后的add方法 col.add("b"); col.add("def"); System.out.println(col); System.out.println(col.toString()); //2,从集合中删除元素。remove(Object o)方法 col.remove("b"); //删除后，集合元素为[abc, def] //3,判断集合中是否包含指定元素。contains(Object o)方法 System.out.println(col.contains("abc")); //4,获取集合元素个数。size()方法 System.out.println(col.size()); //5,返回包含集合中所有元素的数组。toArray()方法 Object[] array = col.toArray(); for(Object bb:array){ System.out.println(bb); } //数组中的元素为{"abc", "def"} //6,清除集合元素。remove()方法 //col.clear(); //清空后，集合元素为[]，代表没有元素 } }
2、Iterator迭代器
（1）Iterator迭代器介绍：
迭代：
Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
集合中把这种取元素的方式描述在Iterator接口中
Iterator接口的常用方法：
hasNext（）：boolean类型，判断集合是否有下一个元素可以迭代，如果集合中有元素，可以迭代，则返回true，反之返回false
Next（）：返回下一个迭代元素
在Collection接口描述了一个抽象方法iterator方法，所有Collection子类都实现了这个方法，并且有自己的迭代形式。
在Collection接口有一个Iteratoral超级接口，里面有一个方法，来获取 Iterator对象
iterator（）：返回在此Collection的元素上进行迭代的迭代器
格式：
Collection<String> coll = new ArrayList<String>();
//2.获取容器的迭代器对象。通过iterator方法。
Iterator it = coll.iterator();
用法实例：
package demo05; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo01 { public static void main(String[] args) { Collection<String> col=new ArrayList<String>(); col.add("a");col.add("b"); col.add("c");col.add("d"); col.add("e");col.add("f"); Iterator it=col.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } }
集合元素的向下转型
集合中可以存储任何对象，存放进去的数据都成了Object。
注意：
集合中存储其实都是对象的地址。
集合中可以存储基本数值因为出现了基本类型包装类，它提供了自动装箱操作（基本类型à对象），这样，集合中的元素就是基本数值的包装类对象。
存储时提升了Object。取出时要使用元素的特有内容，必须向下转型。
String str = (String) it.next();
System.out.println(str.length());
注意：
Iterator接口也可以使用<>来控制迭代元素的类型的。
Collection<String> coll = new ArrayList<String>(); coll.add("abc"); coll.add("aabbcc"); coll.add("cat"); Iterator<String> it = coll.iterator(); while (it.hasNext()) { String str = it.next(); //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型 System.out.println(str.length()); }
迭代器使用示例：
package demo01; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo01 { public static void main(String[] args) { Demo01 p=new Demo01(); p.method(); p.method02(); p.method03(); } public void method(){ Collection<String> col=new ArrayList<String>(); col.add("zbc"); col.add("bhjbh"); col.add("vsnaj"); col.add("abvij"); //获取迭代器对象 Iterator<String> it=col.iterator(); //迭代器进行迭代 while(it.hasNext()){ System.out.println(it.next()); } } public static void method02(){ Collection<Person> col=new ArrayList<Person>(); col.add(new Person("zhangsan",12)); col.add(new Person("lisi",14)); Iterator<Person> it=col.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } public static void method03(){ Collection col=new ArrayList(); col.add("111"); col.add(123); //获取迭代器对象 Iterator it=col.iterator(); while(it.hasNext()){ Object obj=it.next();//it.next（）是匿名函数，只能用一次，先定住it，next类型object，定以后可以重复用 if(obj instanceof String){ String s=(String)it.next();//向下转型 System.out.println(s); } } } }
3、增强for循环
（1）
增强for循环是
专门用来遍历数组和集合的
内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：
for（数据类型 变量名：容器）{ }
它用于遍历Collection接口和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
package demo02; import java.util.ArrayList; public class Demo03 { public static void main(String[] args) { //遍历数组 String[] arr={"a","d","f"}; for(String str:arr){ System.out.println(str); System.out.println(str.length()); } //遍历集合 ArrayList<Integer> list=new ArrayList<Integer>(); list.add(123); list.add(1234); list.add(34); for(Integer s:list){ System.out.println(s); } } }
注意：
增强for循环和老式的for循环有什么区别？
增强for循环必须有被遍历的目标。目标只能是Collection或者是数组。
建议：遍历数组时，如果仅为遍历，可以使用增强for如果要对数组的元素进行 操作，使用老式for循环可以通过下标操作。
增强for底层就是Iterator迭代器
4、泛型
（1）泛型的引入
注意：
集合就要添加泛型。泛型不进class文件，class文件里没有泛型一说，泛型和注释都不进class文件
集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
集合中什么类型的元素都可以存储。导致取出时，如果出现强转就会引发运行时 ClassCastException。怎么来解决这个问题呢？使用集合时，必须明确集合中元素的类型。这种方式称为：泛型。
（2）泛型的定义与使用
含有泛型的类
定义格式：
修饰符 class 类名<代表泛型的变量> { }
class ArrayList<E>{ public boolean add(E e){ } public E get(int index){ } }
创建对象时确定泛型的类型
格式：
例如：ArrayList<String> list = new ArrayList<String>();
ArrayList<Integer> list = new ArrayList<Integer>();此时，变量E的值就是Integer类型
（3）使用泛型的好处
将运行时期的ClassCastException（类型转换异常），转移到了编译时期变成了编译失败。
5、List接口
（1）List接口的概述：
在Collection中有两个接口：List和Set接口，
List接口可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素
List接口：
l 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
l 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
l 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
List接口的常用子类有：
l ArrayList集合
l LinkedList集合
（2）List接口中的常用方法：
l 增加元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移
l 删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
l 替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
l 查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素
package demo03; import java.util.ArrayList; import java.util.List; public class Demo01 { public static void main(String[] args) { List<String> list=new ArrayList<String>(); list.add("哆啦a梦");//向集合尾部添加元素 list.add("大熊");//向集合尾部添加元素 //指定位置添加指定元素 list.add(1,"静香"); /*for(int i=0;i<list.size();i++){ System.out.println(list.get(i)); }*/ String str = list.remove(2); //修改指定下标的元素值 list.set(1, "胖虎"); System.out.println(str); //获取指定下标的值 for(int i=0;i<list.size();i++){ System.out.println(list.get(i)); } } }
（3）Iterator的并发修改异常
在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素
public class IteratorDemo { //在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素 public static void main(String[] args) { //创建List集合 List<String> list = new ArrayList<String>(); //给集合中添加元素 list.add("abc1"); list.add("abc2"); list.add("abc3"); list.add("abc4"); //迭代集合，当有元素为"abc2"时，集合加入新元素"a" Iterator<String> it = list.iterator(); while(it.hasNext()){ String str = it.next(); //判断取出的元素是否是"abc2"，是就添加一个新元素 if("abc2".equals(str)){ list.add("a");// 该操作会导致程序出错 } } //打印容器中的元素 System.out.println(list); } }
运行后出现
java.util.ConcurrentModificationException========================并发修改异常
如何解决这个问题：
在迭代时，不要使用集合的方法操作元素。
（4）List集合存储元素的结构：
数据存储的常用结构有：堆栈、队列、数组、链表。
特点：
堆栈：先进后出
队列：先进先出
数组：查找快，增删慢，ArrayList集合数据存储的结构是数组结构
链表：查找满增删快， LinkedList集合数据存储的结构是链表结构
链表结构：LinkedList查找慢，增删快，因此其提供了很多增、删的方法
addFirst（）将指定元素插入表头
addLast（） 将指定元素 插入 最后
getFirst（）返回第一个元素
getLast（）返回最后一个元素
removeFirst()移除并返回第一个元素
removeLast()移除并返回最后一个元素
isEmpty():boolean类型，列表不含数据返回true
6、Set接口
（1）概述
List中是可以存放重复元素的，Set接口，它里面的集合，所存储的元素就是不重复的。
Set集合通过元素的equals方法，来判断是否为重复元素，
（2）HashSet集合
HashSet集合不能保证的迭代顺序与元素存储顺序相同。
HashSet集合实现Set接口，由哈希表支持
什么是哈希表呢？
哈希表底层，使用的也是数组机制，数组中也存放对象，而这些对象往数组中存放时的位置比较特殊，
当需要把这些对象给数组中存放时，那么会根据这些对象的特有数据结合相应的算法，计算出这个对
象在数组中的位置，然后把这个对象存放在数组中。而这样的数组就称为哈希数组，即就是哈希表。
当向哈希表中存放元素时，需要根据元素的特有数据结合相应的算法，这个算法其实就是Object类中的hashCode方法。
由于任何对象都是Object类的子类，所以任何对象有拥有这个方法。即就是在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。
HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。
给HashSet中存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法，因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等。
如：
package demo05; import java.util.HashSet; public class Demo { public static void main(String[] args) { Object obj=new Object(); System.out.println(obj.hashCode()); HashSet<String> set=new HashSet<String>(); set.add("abc"); set.add("bcd"); set.add("ace"); set.add("abc"); for(String s:set){ System.out.println(s); System.out.println(s.hashCode()); } } }
总结：
哈希不能存储重复元素的原因：
当set集合存元素的时候，先调用该元素类型的hashcode方法计算哈希值，先去数组中看下有没有重复的哈希值，如果没有，则添加上，如果有，则继续调用该元素类型的equals方法判断内容，如果内容相同，则丢掉（其实是覆盖掉），如果内容不同，则添加上
（3） HashSet存储自定义类型元素
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
package demo05; public class Person { String name; int age; public Person(String name, int age) { super(); this.name = name; this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
package demo05; import java.util.HashSet; public class Demo03 { public static void main(String[] args) { HashSet<Person> set=new HashSet<Person>(); set.add(new Person("a",18)); set.add(new Person("b",17)); set.add(new Person("c",19)); set.add(new Person("a",18)); for(Person p:set){ System.out.println(p); } } }
（4） LinkedHashSet介绍
HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序
在HashSet下面有一个子类LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。
public class LinkedHashSetDemo { public static void main(String[] args) { Set<String> set = new LinkedHashSet<String>(); set.add("bbb"); set.add("aaa"); set.add("abc"); set.add("bbc"); Iterator it = set.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }
输出结果如下，LinkedHashSet集合保证元素的存入和取出的顺序：
bbb
aaa
abc
bbc