java超强学习笔记(二)

集合：保存多个其他对象的对象，不能保存简单类型
 List：有序(存放元素的顺序)，可重复的集合
  ArrayList：实质就是一个会自动增长的数组
   查询效率比较高，增删的效率比较低，适用于查询比较频繁，增删动作较少的元素管理的集合。
   加载大批量的数据时，先进行手动扩容(就是调用ensureCapacity(int minCapacity)方法)，这样可以提高效率。
   
  LinkedList：底层是用双向循环链表来实现的
   查询效率低，但是增删效率很高，适用于增删动作的比较频繁，查询次数较少的元素管理的集合

 Set：无序的，不允许有重复元素的集合
  HashSet：
   Object类中的hashCode()的方法是所有类都会继承的方法，这个方法会算出一个Hash码值返回，HashSet会用Hash码值去和数组长度取模，对象的模值(这个模值就是对象要存放在数组中的位置，和数组的下标相同)相同时才会判断数组中的元素和要加入的对象的内容是否相同，如果不同才会再找位置添加进去，相同则不允许添加。
   如果数组中的元素和要加入的对象的hashCode()返回了相同的Hash码值，才会用equals()方法来判断两个对象的内容是否相同。 
   注意：要存入HashSet的集合对象中的自定义类必须覆盖hashCode()、equals()两个方法，才能保证集合中元素不重复。
   
  TreeSet：可排序的Set
   SortedSet接口是Set的子接口，TreeSet是SortedSet接口的实现类，他可以对集合中的元素进行排序。
   
   将自定义类的对象存放在TreeSet中，这个类需要实现了Comparable接口，TreeSet可以自动过滤掉重复元素所以不在需要重载hashCode()方法，TreeSet会根据比较规则判断元素内容是否相同，不同则会存入，TreeSet会在元素存入时就进行排序。
   
   Comparable接口：
    也叫做可比较接口，这个接口在java.lang包下，只要根据指定类型的排序规则实现了这个接口，就是可排序的。
    这个接口中只定义了一个 compareTo(Object o) 方法，该方法的返回值类型是整型，如果当前对象大于参数对象就返回正数，当前对象等于参数对象就返回0，当前对象小于参数对象就返回负值，这样写就是升序排列，反之则是进行降序排列。
    
   Comparator接口：
    比较器Comparator接口，是另一种对自定义类型对象的集合整体排序的方法，存在于java.util包下。
    这个接口中定义了一个 compare(Object o1,Object o2) 方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是一样。
    利用这种方式，则在创建集合的时候把定义好的比较器作为参数，构造一个集合
    
 Map：存放key-value对(有关系的两个对象，一个做key，一个做value，同时存入)
  HashMap：基于哈希表的 Map 接口的实现，此实现提供所有可选的映射操作，并允许使用 null 值和 null 键
   遍历：
    先调用keySet()得到key的set集合，
    再迭代遍历key的set集合，
    根据key得到value。
    
  Hashtable：同HashMap，一般不使用
  
  HashMap与Hashtable的区别：
   HashMap：非线程安全，不支持并发控制，允许空的键值对。
   Hashtable：是线程安全，支持并发控制，不允许有空的键值对。
   
  SortedMap接口：Map的子接口，按某一特定排序规则来存放所加入的键值对
   实现类：TreeMap类。
    Key值的排序规则，同SortedSet接口实现类TreeSet
    
  注意：
   key一般是8种基本类型的封装类或者是String类，拿自己自定义的类作为Key没有意义。
   key不可重复，value可以重复
    

反射：
 反射：在运行时动态分析或使用一个类进行工作。
 java.lang.Class类：描述类信息的类。
 类对象：描述一个类信息的对象，当虚拟机加载类的时候，就会创建这个类的类对象并加载该对象，Class是类对象的类型。
 
 获得类对象的方式：
  用" 类名.class "获得这个类的类对象。
  用类的对象掉用getClass()，如object.getClass()得到这个对象的类型的类对象。
  可以使用Class.forName(类名)，也可以得到这个类的类对象，（注意，这里写的类名必须是全限定名（全名），是包名加类名，XXX.XXX.XXXX）。
  基本类型也有类对象，用" 封装类.TYPE "可以获得对应的基本类型的类对象。

 java.lang.reflect包下的三个重要类：
  Field属性类：用来描述属性的信息。
  Method方法类：方法的信息的描述。
  Constructor构造方法类：用来描述构造方法的信息。

 Class类中的常用方法：
  newInstance()
   创建此 Class 对象所表示的类的一个新实例(调用无参构造创建的对象)。
  getDeclaredMethods()
   获得的是一个Method方法类对象的数组，获得本类(不包括父类)声明的所有(包括private的)方法对象。
  getMethods()     //推荐使用
   获得的是一个Method方法类对象的数组，获得所有(父类的也包括)publice的方法对象。
  getDeclaredConstructors()
   获得的是一个Constructor构造方法类对象的数组，获得这个类声明的所有构造方法对象。
  getConstructors()    //推荐使用
   获得的是一个Constructor构造方法类对象的数组，获得所有publice的构造方法对象。
  getDeclaredFields()    //推荐使用
   获得的是一个Field属性类对象的数组，获得本类声明的所有属性的属性对象。
  getFields()
   获得的是一个Field属性类对象的数组，获得所有publice的属性对象。
   
 使用反射构造一个类的对象的步骤：
  a. 获得类对象
  b. 获得构造方法对象
  c. 获得对象，用构造方法对象调用构造方法，如果使用无参构造方法，可以跳过第二步，直接使用" 类对象.newInstance() "方法来获得这个类的对象
  d. 获得方法对象
  e. 用方法对象调用方法（用这个类的对象作为第一参数）
  如下面的例子：
   反射机制的实现类：
    package day07.reflect;    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;   
    public class TestReflect {     
     public static Object get(String className , Map map) throws Exception{
      Class c = Class.forName(className);                  //获得类对象
      Object o = c.newInstance();                   //获得对象
      Set set = map.keySet();
      for(String str : set){
       String s = "set" + str.substring(0,1).toUpperCase()+str.substring(1);
       Field f = c.getDeclaredField(str);
       Method m = c.getMethod(s, f.getType());        //获得方法对象
       m.invoke(o, map.get(str));                       //用方法对象调用方法
      }
      return o;
     }
     
     public static void main(String[] args) throws Exception { 
      Map m = new HashMap();
      m.put("name", "zhang");
      m.put("age", 22);
      Object o = get("day07.reflect.Student",m);
      Student s = (Student) o;
      System.out.println(s.getName() + "   " + s.getAge());
      
      Map m1 = new HashMap();
      m1.put("name", "li");
      m1.put("gender", "男");
      Object o1 = get("day07.reflect.Teacher",m1);
      Teacher t = (Teacher) o1;
      System.out.println(t.getName() + "    " + t.getGender());
     }
    }
   学生类：
    package day07.reflect;    
    public class Student {
     private String name;    
     private int age;    
     public int getAge() {
      return age;
     }    
     public void setAge(int age) {
      this.age = age;
     }    
     public String getName() {
      return name;
     }    
     public void setName(String name) {
      this.name = name;
     }
    } 
   教师类：
    package day07.reflect;    
    public class Teacher {
     private String name;    
     private String gender;    
     public String getGender() {
      return gender;
     }    
     public void setGender(String gender) {
      this.gender = gender;
     }      
     public String getName() {
      return name;
     }    
     public void setName(String name) {
      this.name = name;
     }    
    }
 
内部类：
 定义：
  定义在另外一个类中的类，就是内部类。
  编译后生成的两个独立的类：Outer.class 和Outer$Inner.class。
  
 内部类的分类：
  静态内部类：静态内部类定义在类中，任何方法外，用static修饰
   静态内部类只能访问外部类的静态成员。
   在外部类的外部，要创建一个静态内部类对象不需要外部类对象：
    Outer.Inner in = new Outer.Inner();
   在本类内部生成内部类对象的方式：
    Inner in = new Inner(); 
 
  成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列
   在内部类中可以直接访问外部类的私有属性。
   内部类和外部类的实例变量允许命名冲突。
    在内部类中访问实例变量：this.属性
    在内部类访问外部类的实例变量：外部类名.this.属性
   在外部类的外部，要创建一个成员内部类对象，要首先建立一个外部类对象，然后再创建一个成员内部类对象。
    Outer out = new Outer();
    Outer.Inner in = out.new Inner();
   在本类内部生成内部类对象的方式：
    在静态方法中：Inner in = new Outer().new Inner();
    在非静态方法中：Inner in = this.new Inner();
   成员内部类不可以有静态成员，这是因为静态属性是在加载类的时候创建，这个时候内部类还没有被创建。
    
  局部内部类：在外部类的方法中定义的内部类
   与局部变量类似，在局部内部类前不可以加修饰符public和private，其作用域为定义它的代码块。
   局部内部类不仅可以访问外部类的实例变量，还可以访问外部类的局部变量，但要求外部类的局部变量必须为final的。
   配合接口使用，来做到强制弱耦合。
   在外部类的外部不可创建局部内部类对象，只能在局部内部类所在的方法中创建：
    Inner in = new Inner();
   
  匿名内部类：一种特殊的局部内部类
   没有名字，也没有class、extends、implements关键字
   用一种隐含的方式实现一个接口或继承一个类，并且只能创建一次实例。
   实现方式：在某个语句中，new 父类/父接口名字(){ 类体中实现方法 }
    例如：
     TreesSet ts = new TreeSet(new Comparator(){
      public int compare(Object o1, Object o2){
       return 0;
      }
     });
   匿名内部类属于局部内部类，那么局部内部类的所有限制都对其生效。
   匿名内部类是唯一一种无构造方法的类，因为构造器的名字必须合类名相同，而匿名内部类没有类名。