一、内部类

把一个类放在另一个类的内部定义，定义在其他类内部的类就称之为内部类（嵌套类），包含内部类的类称之为外部类（宿主类）。
内部类分为：成员内部类、局部内部类、匿名内部类、静态内部类。
1、成员内部类可以任意访问外部类的所有成员变量和成员方法（包括private成员和静态成员）。访问外部类的形式：外部类.this.成员变量 外部类.this.成员方法；
2、匿名内部类能够在实现父类或者接口中的方法的情况下同时产生一个相应的对象，前提是者个父类或者接口必须先存在。

二、集合

  1. 集合中只能存放引用类型的数据；集合是不定长的；存放到同一集合中的数据，其类型可以不一样；其主要分为：Set(HashSet)  List(ArrayList  LinkedList)  Map(HashMap)。<br />    Collection接口：定义了操作集合的常用方法。两个常用子类接口：List接口：存放有序且有重复元素的集合； Set接口：存放无需且不包含重复的元素集合。

1、Interator:迭代器。他是java集合的顶层接口。

  1. 具体用法：Object next();//返回迭代器刚约过的元素的引用，返回值Object需要强制转换成自己需要的类型。<br />    Boolean hasNext();//判断容器内是否还有供访问的元素<br />    Void remove();//删除迭代器刚越过的元素。
  1. //产生一个 List 集合，典型实现为 ArrayList。 List list = new ArrayList();
  2. //添加三个元素
  3. list.add("Tom");
  4. list.add("Bob"); 
  5. list.add("Marry");
  6. //构造 List 的迭代器
  7. Iterator it = list.iterator();
  8. //通过迭代器遍历元素         while(it.hasNext()){
  9.  Object obj = it.next();            System.out.println(obj);}

2、Collection集合：

  1.    Collections :集合的工具类<br />Collections.sort(集合名称)；//对集合进行排序<br />S1.compareTo(s2);//比较对象s1和s2<br />想要使用排序功能，集合中的元素必须实现Comparable接口，实现compareTo（）方法。
  1. //compare 比较
  2. public class Student implements Comparable<Student>{
  3. public int compareTo(Student other) {
  4.         // TODO Auto-generated method stub
  5.         //进行比较的对象: this(s1)  other(s2)
  6.         //按照学号排序
  7.         //return this.num - other.num;
  8.         //按照年龄排序
  9.         //return this.age-other.age;
  10.         //按照姓名排序
  11.         //return this.name.compareTo(other.name);
  12.         //先按照年龄排序，如果年龄一样，在按照学号排序
  13.         if(this.age == other.age) {
  14.             return this.num - other.num;
  15.         }else {
  16.             return this.age - other.age;
  17.         }
  18. }
  1. //我们这里将 ArrayList集合作为 Collection 的实现类         
  2. Collection collection = new ArrayList(); 
  3. //添加元素
  4. collection.add("Tom");
  5. collection.add("Bob");
  6. //删除指定元素 
  7. collection.remove("Tom"); 
  8. //删除所有元素
  9. Collection c = new ArrayList();
  10. c.add("Bob");
  11. collection.removeAll(c)
  12. //检测是否存在某个元素
  13.  collection.contains("Tom");
  14. //判断是否为空
  15. collection.isEmpty();
  16. //使用foreach循环遍历集合
  17. For（Object ob : collection）{
  18. System.out.println(ob);  }
  19. //使用迭代器 Interator
  20. Interator  iter = collection.iterator();
  21. Whil(iterator.hasNext()){
  22. Object ob = iterator.next();
  23. System.out.println(ob);
  24. }

3、List
List接口的实现：List li = new ArrayList();
List li2 = new LinkedList();
Li.add(“abc”);//添加元素
Iterator it = li.iterator();//构造List迭代器
Li.add(2,“”);//在指定位置添加元素
Li.set(2,“”)；//在指定位置替换元素
Int i= li.indexOf(2);//获取指定位置的索引
for(int j=0;j<list.size();j++){}//遍历集合

三、泛型、集合排序

1、泛型

  1.        泛型就是“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（类型形参），然后使用/调用时传入具体的类型（类型实参）。
  1. public class Box<D> {
  2. private D obj;
  3. //放数据的方法
  4. //泛型方法
  5. public void put(D obj) {
  6.     this.obj = obj;
  7.     System.out.println("把"+obj+"存起来");}
  8.     public D get() {
  9.         return this.obj;
  10.     }
  12. List<Student> list = new ArrayList();
  13. //jdk 1.7之前使用
  14. //List<Student> list1 = new ArrayList<Student>();
  15. Student s = new Student("聂金", 20);
  16. Student s1 = new Student("陈一发", 22);
  17. list.add(s);
  18. list.add(s1);
  19. Student s2 = list.get(1);
  20. Box<String> b = new Box();
  21. b.put("abc");
  22. String s3 = b.get();

List

  1.   **ArrayList **<br />                  1、底层使用数组；<br />                  2、查找元素时，效率高；<br />                  3、插入元素或删除元素时，效率低；<br />      **LinkedList**<br />                  1、底层使用双向链表实现<br />                  2、查找元素时，效率低<br />                  3、插入元素或者删除元素时，效率高；<br />     ** Set**（去重时：根据对象的hashCode值；equals。  添加元素时，获取新元素的hashCode值，和集合中原有元素的hashCode值比较。如果都不一样，新元素就是不同的元素，就存放到set了，如果存在相同情况，会继续调用对象的equals方法，判断是否是同一个对象。实现去重，需要手动手写hashCode()和equals(),指定去重原则（根据对象的属性））<br />    **  HashSet**<br />                  1、元素无序（存进去的顺序和取出的顺序不一样）；<br />                  2、不能重复<br />     ** LinkedHashSet**<br />                  1、元素有序（存进去的顺序和取出的顺序一样）；<br />                  2、元素不重复<br />      **TreeSet**<br />                  1、元素不重复；<br />                  2、元素是经过排序的（按照英文字母顺序排列）<br />

Map

  1.   **HashMap**<br />                 1、元素无序<br />      **LinkedHashMap**<br />                 1、元素有序<br />      **TreeMap**<br />                 1、元素经过排序（根据key值排序）

四、Map

Map : 以健值对的形式存放数据。Map中的数据是无序的；有两个键值对（key 和 value）；
Map中的key值不能重复，如果可以值重复，后添加的数据会覆盖之前的数据。

  1. 使用方法：Map<String(key),String(value)> map = new HashMap();
  2. Map.put(“”,“”);//存放数据
  3. Map.get(“”);//根据key值获取对应的value值
  4. Map.size();//获取map中键值对的数量
  5. Map.remove(key);//根据key值删除元素
  6. Map.containsKey(key);//判断map中是否包含某个key值
  7. Map.containsValue(value);//判断map中是否包含某个value值
  8. Map.clear();//清空数据
  9. //获取map中的所有key值，得到的是set集合
  10. Set<String> set = map.keySet();
  11. for(String k : set) {
  12.     System.out.println(k);
  13.     String value = map.get(k);
  14.     System.out.println(k+":"+value);
  15. }
  16. //获取map中所有的value值
  17. Collection<String> values = map.values();
  18. for(String s : values) {
  19.     System.out.println(s);
  20. }