Java

IDEA 快捷键与一些配置

• ctrl + p 查看函数参数
• ctrl + h 可查看该类的继承类/接口的实现方法
• ctrl + f12：获取当前类的结构
• alt + insert ：插入构造方法，set方法，get方法等
• ctrl + o:重写

泛型类/接口

• 定义：

  class/interface name <T>{
  	private T var1;
      public T fun1(){
  	}
  }

• 字母规范：可以是任何大写字母

  • E — Element，常用在java Collection里，如：List,Iterator,Set。
  • K,V — Key，Value，代表Map的键值对。
  • N — Number，数字。
  • T — Type，类型，如String，Integer等等。

• 使用时传入类型参数：

  基本数据类型	对应的引用数据类型 表示形式
  byte	Byte
  short	Short
  int	Integer
  long	Long
  float	Float
  double	Double
  char	Character
  boolean	Boolean

• 泛型接口的使用

  1. 使用非泛型类实现接口：

     interface Info<T>{          
         public T getVar() ; 
         public void setVar(T x);  
     }    
     
     //实现：
     class InfoImpl implements Info<String>{    
         private String var ;                // 定义属性  
         public InfoImpl(String var){        // 通过构造方法设置属性内容  
             this.setVar(var) ;  
         }  
         @Override  
         public void setVar(String var){  
             this.var = var ;  
         }  
         @Override  
         public String getVar(){  
             return this.var ;  
         }  
     }  
       
     public class GenericsDemo24{  
         public  void main(String arsg[]){  
             InfoImpl i = new InfoImpl("harvic");  
             System.out.println(i.getVar()) ;  
         }  
     }; 

     • 在实现接口时，直接对方法进行重写并且用String填充，没有用泛型类指明接口中的。

  2. 使用泛型类实现

     interface Info<T>{          
         public T getVar() ; 
         public void setVar(T x);  
     }    
     
     //类实现
     class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
         private T var ;             // 定义属性  
         public InfoImpl(T var){     // 通过构造方法设置属性内容  
             this.setVar(var) ;    
         }  
         public void setVar(T var){  
             this.var = var ;  
         }  
         public T getVar(){  
             return this.var ;  
         }  
     }  
     public class GenericsDemo24{  
         public static void main(String arsg[]){  
             InfoImpl<String> i = new InfoImpl<String>("harvic");  
             System.out.println(i.getVar()) ;  
         }  
     };  

     • 直接使用泛型类将传给接口中的，可以使用户决定具体的类型，不会像非泛型类在类中写死。

泛型方法

• 定义：

  • 修饰符 + + 返回类型 + 名字(T x)

  • 例子：

    class Fans{
        public static <T> void func1(T x){
    		System.out.println(x.toString());
        }
        //静态方法
        
        public <T> void func2(T x){
    		System.out.println(x.toString());
        }jin
        //普通方法
    }
    
    
    //使用
    //静态方法
    Fans.func1("abc");
    Fans.<String>func1("abc");
    
    //普通方法
    Fans fan = new Fans();
    fans.func2("abc");
    fans.<String>func2("abc");

其他用法

• 可变参数：

  public static void func1(int...args){
      for(int i = 0 ; i<args.length ; i++)
  }
  //args二维数组；
  //本质和一样
  public static void func1(int args[]){
      for(int i = 0 ; i<args.length ; i++)
  }

• 函数返回泛型与使用Class传入泛型类

  public static <T> List<T> parseArray(String response,Class<T> object){  
      List<T> modelList = JSON.parseArray(response, object);  
      return modelList;  
  }  

  函数定义了一个泛型变量，且返回类型为List也包含泛型，函数传入参数中使用Class来传递泛型类

  具体调用：

  List<mymodel> list = parseArray("hello",mymodel.class)

• 返回泛型数组

  • 普通定义数组：

    String[] list = new String[8];

  • 泛型数组：

    //定义  
    public static <T> T[] fun1(T...arg){  // 接收可变参数    
           return arg ;            // 返回泛型数组    
    }    
    //使用  
    public static void main(String args[]){    
           Integer i[] = fun1(1,2,3,4,5,6) ;  
           Integer[] result = fun1(i) ;  
    }
    //使用Compara

运算符

• 扩展赋值运算符可以自动强制转换

  byte a = 0；a = a + 1;//错误a += 1;//正确，自动强转

• 除了 == 其他关系运算符只支持数值类型运算。不能进行引用类型比较（String），若引用类型之间没有继承关系，也不能使用 == 进行比较。

• 逻辑运算符:&两个都进行判断，&&会短路。|与||同理。

• ^: 异或，~：取反，>>>：无符号右移：高位补0。

数组

• 栈中保存引用变量值：指向堆中对象的值。

• 数组声明，动态：

  int [] a = new int[3];
  int [][] b = new int [3][2];
  
  //通过静态初始化实现锯齿数组
  //动态实现锯齿数组
  int [] a = new int [3][];
  a[0] = new int[5];
  a[1] = new int[4];
  a[2] = new int[3];

• 复制：调用a.clone()进行复制。

方法

• 每调用一个方法，JVM创建一个栈帧，结束返回时，释放对应的栈帧。

类

• 代码块

  • 普通代码块
    • 方法中
  • 构造代码块
    • 类中，在构造方法前被调用，可用于：初始化时，将一个类中多个构造方法的相同部分放在构造代码块中，提高复用性和效率
  • 静态代码块
    • static关键字修饰的代码块：最先运行且只运行一次。
  • 同步代码块

• 内部类

  • 外部类只能用public或者默认访问模式修饰

  • 成员内部类

    • 作为外部类的一个成员**。不能有静态的成员**，方法和静态内部类。因为外部类加载时内部类是非静态的，不会初始化静态成员。
    • 内部类访问外部类： 可以直接访问外部类变量: 外部类.this.变量或直接使用变量名访问非同名外部类变量
    • 外部类外访问内部类：外部类.内部类.obi = new 外部类().new 内部类()(通过外部类对象创建内部类对象)

  • 静态内部类

    • static关键字修饰，可以有静态成员和实例成员。
    • 静态方法只能访问静态变量。
    • 内部类中访问外部类：
      • 可以直接访问静态成员
      • 实例成员需要通过 外部类.this.变量进行访问。
    • 外部类外访问内部类
      • 访问内部类静态成员:外部类.内部类.变量
      • 访问内部类实例成员: 外部类.内部类.obj = new 外部类.内部类()

  • 方法内部类

    • 在方法中创建类，只能在方法中被实例化（代码块的变量作用域）

  • 匿名内部类

    • 不能加访问修饰符。

    • 立即创建一个匿名类的对象：该类的定义立即消失，因此不能重复使用。

      Anonymous obj = new Anonymous(){	//Anonymous在使用前已被定义
      	public Anonymous{
      		
      	}
      	public void say(){
      		System.out.println("匿名内部类")
      	}
      }

• 继承

  this()//该对象super()//父类对象

  • 重写修改访问权限。

  • final

    • 修饰类
    • 修饰方法
    • 修饰变量

  • abstract与interface

    • interface中变量为static final，方法为abstract，可以多继承与多实现。

    • abstract中可以有实例变量与静态变量，可以有构造方法，抽象方法与普通方法。

• 多态

  • 父类引用变量引用不同子类对象，可以调用同名方法实现不同功能。

    • 动态绑定：沿着实际引用类型的继承链向上，直到找到对应的方法。

      class People{
          public void say(){
              System.out.println("I'm Person");
          }
      }
      class man extends People{
          @Override
          public void say(){
              System.out.println("I'm man");
          }
      }
      
      class son extends man{
      }
      public class test {
          
          public static void main(String[] args) {
              People p;
              p = new son();
              p.say();
      
          }
      }
      //最终执行man类中的say方法。

    • 引用类型：声明类型与实际类型

      • 向上转型
      • 向下转型：被转换的实际类型为转换类或其子类。（声明类型间的转换，实际调用还是看实际类型）
      • instanceof 关键字判断对象是否为类的实例。

    • Object类：

      • toString方法：返回描述该类的字符串，与直接打印该类效果一样。
      • equals方法：比较两个类是否相等：比较是否指向同一地址。若相比较两类中内容是否相同需要重写：如String类中的equals方法。
        • 首先判断是否指向同一对象
        • 然后判断是否为同一类的实例
        • 最后注意检查成员变量是否相同。

常见模式

• 单例模式：

/*  单例模式，程序运行期间，一个类只有一个实例，且自动实例化向系统提供
*   因此类中的构造方法为私有的，防止外部调用
*   类中含有一个该类的静态私有对象。
*   设置一个静态的公有的获取该对象的方法.
*
*/

class Single{
    int num;
    private Single(){
        num = 0;
    }
    private static Single single = new Single();
    public static Single getSingle(){
        return single;
    }
}
public class SingleModel {
    public static void main(String[] args) {
        Single s1,s2;
        s1 = Single.getSingle();
        s2 = Single.getSingle();

        System.out.println(s1);
        System.out.println(s2);
/*        try{
            int a = 1/0;
        }
        catch (Exception e){
            System.out.println(e);
            e.printStackTrace();
        }
*/
    }

}

• 工厂模式：动态的绝对产生哪个类的实例。

  • 简单工厂模式：工厂类中定义一个静态方法根据参数决定产生实现了同一接口的不同的类的实例：

  //产品接口
  interface Product{
      
  }
  //实现产品接口的fruit类
  class Fruit implements Product{
      public Fruit(){
          System.out.println("fruit is produced");
      }
  }
  
  //实现产品接口的vegetables类
  class Vegetables implements Product{
      public Vegetables(){
          System.out.println("vegetables is produced");
      }
  }
  
  //简单工厂类
  class Factory{
      public Factory(){
  
      }
      public static Product produce(String name){
          if (name == null){
              System.out.println("name cant be null");
          }
          if(name.equals("Fruit")){
              return new Fruit();
          }
          else if(name.equals("Vegetables")){
              return new Vegetables();
          }
          else{
              System.out.println("wrong product,please enter correct product");
              return null;
          }
      }
  }
  public class SimpleFactory {
      public static void main(String[] args) {
          
          //根据不同参数产生不同的实例
          Factory.produce("Fruit");
          Factory.produce("Vegetables");
      }
  
  }
  
  /*	工厂类中静态方法进行实例创建 
  *
  *	增加新的产品模块需要修改工厂类代码
  */

  • 方法工厂模式：为工厂类提供一个接口，接口中包含一个创建抽象方法，根据不同的类实现接口从而实现不同实例的创建。

  package Coding.FuncFatory;
  
  interface Product{
  
  }
  //实现产品接口的fruit类
  class Fruit implements Product{
      public Fruit(){
          System.out.println("fruit is produced");
      }
  }
  
  //实现产品接口的vegetables类
  class Vegetables implements Product{
      public Vegetables(){
          System.out.println("vegetables is produced");
      }
  }
  
  //定义工厂接口
  interface Factory{
      public Product produce();
  }
  
  //Fruit工厂实现Factory接口
  class FruitProduced implements Factory{
      public FruitProduced(){
      }
  
      @Override
      public Product produce(){
          return new Fruit();
      }
  }
  //Vegetables工厂实现Factory接口
  class VegetablesProduced implements Factory{
      public VegetablesProduced(){
      }
      @Override
      public Product produce(){
          return new Vegetables();
      }
  }
  
  public class FuncFactory {
      public static void main(String[] args) {
          //定义接口引用变量，通过多态性实现不同的实例化
          Factory factory;
  
          factory = new FruitProduced();
          factory.produce();
  
          factory = new VegetablesProduced();
          factory.produce();
      }
  }
  
  /*	工厂类中静态方法进行实例创建 
  *	新增工厂接口，不同产品实现不同的工厂类。
  *	
  *	新增产品需要创建一个实现类，数量太多不易操作
  */

  • 抽象工厂模式：定义不同产品接口，通过不同实现类对产品进行分类。同时在工厂接口中根据产品类型定义抽象创建方法。

  package Coding.AbstractFactory;
  
  //定义不同产品接口
  interface Product_eat{
  
  }
  
  //定义不同产品接口
  interface Product_play{
  
  }
  
  //实现产品接口的fruit类
  class Fruit implements Product_eat{
      public Fruit(){
          System.out.println("Cheap-Product_eat:[fruit] is produced");
      }
  }
  
  //实现产品接口的vegetables类
  class Vegetables implements Product_eat{
      public Vegetables(){
          System.out.println("Dear-Product_eat:[vegetables] is produced");
      }
  }
  //实现产品接口的Car类
  class Car implements Product_play{
      public Car(){
          System.out.println("Cheap-Product_play:[Car] is produced");
      }
  }
  //实现产品接口的Gun类
  class Gun implements Product_play{
      public Gun(){
          System.out.println("Dear-Product_play:[Gun] is produced");
      }
  }
  
  //定义工厂接口
  interface Factory{
      public Product_eat produce_eat();
      public Product_play produce_play();
  }
  
  //对产品进行分类，通过不同工厂生产不同的产品。
  class Product_CheapFactory implements Factory{
      @Override
      public Product_eat produce_eat() {
          return new Fruit();
      }
  
      @Override
      public Product_play produce_play() {
          return new Car();
      }
  }
  
  class Product_DearFactory implements Factory{
      @Override
      public Product_eat produce_eat() {
          return new Vegetables();
      }
  
      @Override
      public Product_play produce_play() {
          return new Gun();
      }
  }
  
  public class AbstractFactory {
      public static void main(String[] args) {
          Factory factory;
  
          factory = new Product_CheapFactory();
          factory.produce_eat();
          factory.produce_play();
  
          factory = new Product_DearFactory();
          factory.produce_eat();
          factory.produce_play();
      }
      
  }
  
  /*	在工厂方法基础上对工厂进行分类管理，不同工厂生产不同类的一系列多个产品，进行自由组合
  */	

• 代理模式：将真正要做的的操作封装成一个实现类，作为参数传递给代理实现类。

  package Coding.Proxy;
  
  /*
      代理模式：将真正要做的的操作封装成一个实现类，作为参数传递给代理实现类。
  */
  
  interface FindJob{
      public void find();
  }
  
  class Person implements FindJob{
      @Override
      public void find(){
          System.out.println("hand in resume");
      }
  }
  
  class Proxy implements FindJob{
  
      private FindJob find;
  
      //通过构造方法传入实际操作类
      Proxy(FindJob find){
         this.find = find;
      }
  
      @Override
      public void find(){
          System.out.println("accept proxy");
          find.find();
          System.out.println("proxy answer");
          System.out.println("proxy end");
  
      }
  }
  
  public class DoProxy{
      public static void main(String[] args) {
          FindJob find;
          //传入实际操作类，通过代理进行调用并操作。
          find = new Proxy(new Person());
          find.find();
      }
  }

• 异常

  try{
      
  }
  catch{
      
  }
  finally{
      
  }
  //在try catch块中的return语句之前运行，且不会影响return后的表达式。

  • throws：JVM自动实例化异常类对象
  • throw：throw new Exception(String str)：手动抛出异常类对象。
  • 两者都由方法调用者使用try-catch进行捕获。
  • 免检异常：error和RuntimeException子类
  • 必检异常：IOException，SQLException
  • 自定义异常
    • 创建自定义异常继承Exption（必检异常，需要throws声明才能捕获），或继承RuntimeException（免检异常，可以不用throws声明异常）。
    • throw 抛出自定义异常
    • 调用者try-catch捕获异常。

• 多线程

  • Thread:

    • 步骤
      • 子类继承Thread类，重写run方法：线程执行体
      • 创建子类实例：线程对象
      • 对象.run()方法启动线程

    Thread中常用方法：只能单继承，继承一个父类。

    • 构造方法：想调用有参构造方法，需在子类中重写并显示调用父类的构造方法

      Thread() 	
      //默认构造方法，线程名“Thread-n”Thread(String str)	
      //线程名为strThread(Runnable target)		
      //target为run方法被调用的对象Thread(Runnable target,String str)		
      //target为run方法被调用的对象，str为线程名。

    • 其他方法

      //对象方法
      String getName();
      Thread.State getState()		//Thread.State为enum类型。
      
      boolean isAlive();
      void setName(Stirng str);
      void start()
      
      //静态方法
      static void sleep();
      static Thread currentThread() 	//返回当前线程对象引用。

  • Runnable接口：可以继承多个接口 ：重写run方法没有返回值，且不能抛出异常。。

    • 步骤
      • 实现接口
      • 重写run方法
      • 使用Thread(Runnable target)构造方法指定实现接口的类，调用Thread线程对象的start方法

I/O输入输出

• 流：控制文件，内存，I/O设备。

  • 字节流：8bit InputStream OutputStream
  • 字符流16bit Reader Writer

Java数据结构

• Enumeration枚举接口

  • 序号	方法描述
    1	boolean hasMoreElements( ) 测试此枚举是否包含更多的元素。
    2	Object nextElement( ) 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

• BitSet 位集合：处理布尔值非常有用

  • 初始化

    BitSet();BitSet(size);

  • 常用方法：

    • 序号	方法描述
      1	void and(BitSet set) 对此目标位 set 和参数位 set 执行逻辑与操作。
      2	void andNot(BitSet set) 清除此 BitSet 中所有的位，其相应的位在指定的 BitSet 中已设置。
      3	int cardinality( ) 返回此 BitSet 中设置为 true 的位数。
      4	void clear( ) 将此 BitSet 中的所有位设置为 false。
      5	void clear(int index) 将索引指定处的位设置为 false。
      6	void clear(int startIndex, int endIndex) 将指定的 startIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 false。
      7	Object clone( ) 复制此 BitSet，生成一个与之相等的新 BitSet。
      8	boolean equals(Object bitSet) 将此对象与指定的对象进行比较。
      9	void flip(int index) 将指定索引处的位设置为其当前值的补码。
      10	void flip(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的每个位设置为其当前值的补码。
      11	boolean get(int index) 返回指定索引处的位值。
      12	BitSet get(int startIndex, int endIndex) 返回一个新的 BitSet，它由此 BitSet 中从 fromIndex（包括）到 toIndex（不包括）范围内的位组成。
      13	int hashCode( ) 返回此位 set 的哈希码值。
      14	boolean intersects(BitSet bitSet) 如果指定的 BitSet 中有设置为 true 的位，并且在此 BitSet 中也将其设置为 true，则返回 true。
      15	boolean isEmpty( ) 如果此 BitSet 中没有包含任何设置为 true 的位，则返回 true。
      16	int length( ) 返回此 BitSet 的"逻辑大小"：BitSet 中最高设置位的索引加 1。
      17	int nextClearBit(int startIndex) 返回第一个设置为 false 的位的索引，这发生在指定的起始索引或之后的索引上。
      18	int nextSetBit(int startIndex) 返回第一个设置为 true 的位的索引，这发生在指定的起始索引或之后的索引上。
      19	void or(BitSet bitSet) 对此位 set 和位 set 参数执行逻辑或操作。
      20	void set(int index) 将指定索引处的位设置为 true。
      21	void set(int index, boolean v) 将指定索引处的位设置为指定的值。
      22	void set(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 true。
      23	void set(int startIndex, int endIndex, boolean v) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为指定的值。
      24	int size( ) 返回此 BitSet 表示位值时实际使用空间的位数。
      25	String toString( ) 返回此位 set 的字符串表示形式。
      26	void xor(BitSet bitSet) 对此位 set 和位 set 参数执行逻辑异或操作。

• Vector向量类：主要用于事先不知道数组的大小，或者需要一个可变数组的情况，同步的

  • 构造方法

    Vector();//第一种构造方法创建一个默认的向量，默认大小为 10：
    Vector(int size);//二种构造方法创建指定大小的向量。
    Vector(int size,int incr);//第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目。
    Vector(Collection c);//第四种构造方法创建一个包含集合 c 元素的向量：

  • 常用方法

    • 1	void add(int index, Object element) 在此向量的指定位置插入指定的元素。
      2	boolean add(Object o) 将指定元素添加到此向量的末尾。
      3	boolean addAll(Collection c) 将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
      4	boolean addAll(int index, Collection c) 在指定位置将指定 Collection 中的所有元素插入到此向量中。
      5	void addElement(Object obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
      6	int capacity() 返回此向量的当前容量。
      7	void clear() 从此向量中移除所有元素。
      8	Object clone() 返回向量的一个副本。
      9	boolean contains(Object elem) 如果此向量包含指定的元素，则返回 true。
      10	boolean containsAll(Collection c) 如果此向量包含指定 Collection 中的所有元素，则返回 true。
      11	void copyInto(Object[] anArray) 将此向量的组件复制到指定的数组中。
      12	Object elementAt(int index) 返回指定索引处的组件。
      13	Enumeration elements() 返回此向量的组件的枚举。
      14	void ensureCapacity(int minCapacity) 增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
      15	boolean equals(Object o) 比较指定对象与此向量的相等性。
      16	Object firstElement() 返回此向量的第一个组件（位于索引 0) 处的项）。
      17	Object get(int index) 返回向量中指定位置的元素。
      18	int hashCode() 返回此向量的哈希码值。
      19	int indexOf(Object elem) 返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
      20	int indexOf(Object elem, int index) 返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
      21	void insertElementAt(Object obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。
      22	boolean isEmpty() 测试此向量是否不包含组件。
      23	Object lastElement() 返回此向量的最后一个组件。
      24	int lastIndexOf(Object elem) 返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
      25	int lastIndexOf(Object elem, int index) 返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
      26	Object remove(int index) 移除此向量中指定位置的元素。
      27	boolean remove(Object o) 移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
      28	boolean removeAll(Collection c) 从此向量中移除包含在指定 Collection 中的所有元素。
      29	void removeAllElements() 从此向量中移除全部组件，并将其大小设置为零。
      30	boolean removeElement(Object obj) 从此向量中移除变量的第一个（索引最小的）匹配项。
      31	void removeElementAt(int index) 删除指定索引处的组件。
      32	protected void removeRange(int fromIndex, int toIndex) 从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
      33	boolean retainAll(Collection c) 在此向量中仅保留包含在指定 Collection 中的元素。
      34	Object set(int index, Object element) 用指定的元素替换此向量中指定位置处的元素。
      35	void setElementAt(Object obj, int index) 将此向量指定 index 处的组件设置为指定的对象。
      36	void setSize(int newSize) 设置此向量的大小。
      37	int size() 返回此向量中的组件数。
      38	List subList(int fromIndex, int toIndex) 返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
      39	Object[] toArray() 返回一个数组，包含此向量中以恰当顺序存放的所有元素。
      40	Object[] toArray(Object[] a) 返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
      41	String toString() 返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
      42	void trimToSize() 对此向量的容量进行微调，使其等于向量的当前大小。

  • Stack栈：Vector的子类，实现了标准的后进先出

    • 初始化

      Stack()//空栈

    • 常用方法

      • 1	boolean empty() 测试堆栈是否为空。
        2	Object peek( ) 查看堆栈顶部的对象，但不从堆栈中移除它。
        3	Object pop( ) 移除堆栈顶部的对象，并作为此函数的值返回该对象。
        4	Object push(Object element) 把项压入堆栈顶部。
        5	int search(Object element) 返回对象在堆栈中的位置，以 1 为基数。

  • Dictionary字典，抽象类，已过时，常用实现Map接口。

    • 常用方法：

      • 号	方法描述
        1	Enumeration elements( ) 返回此 dictionary 中值的枚举。
        2	Object get(Object key) 返回此 dictionary 中该键所映射到的值。
        3	boolean isEmpty( ) 测试此 dictionary 是否不存在从键到值的映射。
        4	Enumeration keys( ) 返回此 dictionary 中的键的枚举。
        5	Object put(Object key, Object value) 将指定 key 映射到此 dictionary 中指定 value。
        6	Object remove(Object key) 从此 dictionary 中移除 key （及其相应的 value）。
        7	int size( ) 返回此 dictionary 中条目（不同键）的数量。

  • Map接口：

    • 定一个键和一个值，你可以将该值存储在一个 Map 对象。之后，你可以通过键来访问对应的值。

    • 当访问的值不存在的时候，方法就会抛出一个 NoSuchElementException 异常。

    • 当对象的类型和 Map 里元素类型不兼容的时候，就会抛出一个 ClassCastException 异常。

    • 当在不允许使用 Null 对象的 Map 中使用 Null 对象，会抛出一个 NullPointerException 异常。

    • 当尝试修改一个只读的 Map 时，会抛出一个 UnsupportedOperationException 异常。

    • 常用方法：

      • 序号	方法描述
        1	void clear( ) 从此映射中移除所有映射关系（可选操作）。
        2	boolean containsKey(Object k) 如果此映射包含指定键的映射关系，则返回 true。
        3	boolean containsValue(Object v) 如果此映射将一个或多个键映射到指定值，则返回 true。
        4	Set entrySet( ) 返回此映射中包含的映射关系的 Set 视图。
        5	boolean equals(Object obj) 比较指定的对象与此映射是否相等。
        6	Object get(Object k) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
        7	int hashCode( ) 返回此映射的哈希码值。
        8	boolean isEmpty( ) 如果此映射未包含键-值映射关系，则返回 true。
        9	Set keySet( ) 返回此映射中包含的键的 Set 视图。
        10	Object put(Object k, Object v) 将指定的值与此映射中的指定键关联（可选操作）。
        11	void putAll(Map m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。
        12	Object remove(Object k) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
        13	int size( ) 返回此映射中的键-值映射关系数。
        14	Collection values( ) 返回此映射中包含的值的 Collection 视图。

  • HashTable哈希表

    • HashTable实现了Map接口，与HashMap类似，支持同步。指定键值对，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

    • 构造方法：

      Hashtable()
      //第一个是默认构造方法：
      
      Hashtable(int size)
      //第二个构造函数创建指定大小的哈希表：
      
      Hashtable(int size,float fillRatio)
      /*第三个构造方法创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例。
      填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度：
      */
      Hashtable(Map m)
      /*第四个构造方法创建了一个以M中元素为初始化元素的哈希表。
      哈希表的容量被设置为M的两倍。
      */

    • 常见函数

      • 序号	方法描述
        1	void clear( ) 将此哈希表清空，使其不包含任何键。
        2	Object clone( ) 创建此哈希表的浅表副本。
        3	boolean contains(Object value) 测试此映射表中是否存在与指定值关联的键。
        4	boolean containsKey(Object key) 测试指定对象是否为此哈希表中的键。
        5	boolean containsValue(Object value) 如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
        6	Enumeration elements( ) 返回此哈希表中的值的枚举。
        7	Object get(Object key) 返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
        8	boolean isEmpty( ) 测试此哈希表是否没有键映射到值。
        9	Enumeration keys( ) 返回此哈希表中的键的枚举。
        10	Object put(Object key, Object value) 将指定 key 映射到此哈希表中的指定 value。
        11	void rehash( ) 增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。
        12	Object remove(Object key) 从哈希表中移除该键及其相应的值。
        13	int size( ) 返回此哈希表中的键的数量。
        14	String toString( ) 返回此 Hashtable 对象的字符串表示形式，其形式为 ASCII 字符 ", " （逗号加空格）分隔开的、括在括号中的一组条目。

  • Properties类：继承于HashTable。表示一个持久的属性集。键值对都是一个字符串

    • 构造方法：

      Properties()
      // 第一个构造方法没有默认值。
      
      
      Properties(Properties propDefault)
      //第二个构造方法使用propDefault 作为默认值。两种情况下，属性列表都为空：

    • 常用方法

      • 序号	方法描述
        1	String getProperty(String key) 用指定的键在此属性列表中搜索属性。
        2	String getProperty(String key, String defaultProperty) 用指定的键在属性列表中搜索属性。没找到返回default值
        3	void list(PrintStream streamOut) 将属性列表输出到指定的输出流。
        4	void list(PrintWriter streamOut) 将属性列表输出到指定的输出流。
        5	void load(InputStream streamIn) throws IOException 从输入流中读取属性列表（键和元素对）。
        6	Enumeration propertyNames( ) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
        7	Object setProperty(String key, String value) 调用 Hashtable 的方法 put。
        8	void store(OutputStream streamOut, String description) 以适合使用 load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

Java 集合框架

• 顶层接口：Collection,Map接口

• Collection接口分为：List，Set，Queue接口

  • List：有序重复的对象，检索效率高，插入删除效率低。可以动态增长。

  • Set：无需不重复的对象，检索效率低，插入删除效率高。

  • List接口的具体实现类：

    • LinkedList：链表结构，不同步

      • LinkedList 继承了 AbstractSequentialList 类。

      • LinkedList 实现了 Queue 接口，可作为队列使用。

      • LinkedList 实现了 List 接口，可进行列表的相关操作。

      • LinkedList 实现了 Deque 接口，可作为队列使用。

      • LinkedList 实现了 Cloneable 接口，可实现克隆。

      • LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

      • 创建

        LinkedList<String> linkedList = new LinkedList<String>();

      • 常用方法：

      • 方法	描述
        public boolean add(E e)	链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
        public void add(int index, E element)	向指定位置插入元素。
        public boolean addAll(Collection c)	将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
        public boolean addAll(int index, Collection c)	将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
        public void addFirst(E e)	元素添加到头部。
        public void addLast(E e)	元素添加到尾部。
        public boolean offer(E e)	向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
        public boolean offerFirst(E e)	头部插入元素，返回是否成功，成功为 true，失败为 false。
        public boolean offerLast(E e)	尾部插入元素，返回是否成功，成功为 true，失败为 false。
        public void clear()	清空链表。
        public E removeFirst()	删除并返回第一个元素。
        public E removeLast()	删除并返回最后一个元素。
        public boolean remove(Object o)	删除某一元素，返回是否成功，成功为 true，失败为 false。
        public E remove(int index)	删除指定位置的元素。
        public E poll()	删除并返回第一个元素。
        public E remove()	删除并返回第一个元素。
        public boolean contains(Object o)	判断是否含有某一元素。
        public E get(int index)	返回指定位置的元素。
        public E getFirst()	返回第一个元素。
        public E getLast()	返回最后一个元素。
        public int indexOf(Object o)	查找指定元素从前往后第一次出现的索引。
        public int lastIndexOf(Object o)	查找指定元素最后一次出现的索引。
        public E peek()	返回第一个元素。
        public E element()	返回第一个元素。
        public E peekFirst()	返回头部元素。
        public E peekLast()	返回尾部元素。
        public E set(int index, E element)	设置指定位置的元素。
        public Object clone()	克隆该列表。
        public Iterator descendingIterator()	返回倒序迭代器。
        public int size()	返回链表元素个数。
        public ListIterator listIterator(int index)	返回从指定位置开始到末尾的迭代器。
        public Object[] toArray()	返回一个由链表元素组成的数组。
        public T[] toArray(T[] a)	返回一个由链表元素转换类型而成的数组。

    • ArrayList:可以动态改变的数组

      • 创建

        ArrayList arrayList<String> = new ArrayList<String>()

      • 方法	描述
        add()	将元素插入到指定位置的 arraylist 中
        addAll()	添加集合中的所有元素到 arraylist 中
        clear()	删除 arraylist 中的所有元素
        clone()	复制一份 arraylist
        contains()	判断元素是否在 arraylist
        get()	通过索引值获取 arraylist 中的元素
        indexOf()	返回 arraylist 中元素的索引值
        removeAll()	删除存在于指定集合中的 arraylist 里的所有元素
        remove()	删除 arraylist 里的单个元素
        size()	返回 arraylist 里元素数量
        isEmpty()	判断 arraylist 是否为空
        subList()	截取部分 arraylist 的元素
        set()	替换 arraylist 中指定索引的元素
        sort()	对 arraylist 元素进行排序
        toArray()	将 arraylist 转换为数组
        toString()	将 arraylist 转换为字符串
        ensureCapacity()	设置指定容量大小的 arraylist
        lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置
        retainAll()	保留 arraylist 中在指定集合中也存在的那些元素
        containsAll()	查看 arraylist 是否包含指定集合中的所有元素
        trimToSize()	将 arraylist 中的容量调整为数组中的元素个数
        removeRange()	删除 arraylist 中指定索引之间存在的元素
        replaceAll()	将给定的操作内容替换掉数组中每一个元素
        removeIf()	删除所有满足特定条件的 arraylist 元素
        forEach()	遍历 arraylist 中每一个元素并执行特定操作

      • HashSet：无序集合，基于HashMap实现

        • 创建

        HashSet<String> hashset = new HashSet<String>();

        • 常用方法

          add(E e);
          remove(E e);
          clear();
          size();
          for(E e : hashset)
          {    
              System.out.print(e);
          }

      • HashMap:散列表，存储键值对，根据键的HashCode值存储数据，因此键值唯一，最多允许一条键为null

        • 创建方法

          HashMap<String,Integer> hashMap = new HashMap<String,Integer>();

        • 迭代方法：可以使用 for-each 来迭代 HashMap 中的元素。

          如果你只想获取 key，可以使用 keySet() 方法，然后可以通过 get(key) 获取对应的 value，如果你只想获取 value，可以使用 values() 方法。

          keySet() /*获取key值*/
          values() /*获取value值*/

        • java Lambda表达式：

          (parameters) -> expression;
           或
          (parameters) ->{ statements; }

        • 常用方法：

        • 方法	描述
          clear()	删除 hashMap 中的所有键/值对
          clone()	复制一份 hashMap
          isEmpty()	判断 hashMap 是否为空
          size()	计算 hashMap 中键/值对的数量
          put()	将键/值对添加到 hashMap 中
          putAll()	将所有键/值对添加到 hashMap 中
          putIfAbsent()	如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
          remove()	删除 hashMap 中指定键 key 的映射关系
          containsKey()	检查 hashMap 中是否存在指定的 key 对应的映射关系。
          containsValue()	检查 hashMap 中是否存在指定的 value 对应的映射关系。
          replace()	替换 hashMap 中是指定的 key 对应的 value。
          replaceAll()	将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
          get()	获取指定 key 对应对 value
          getOrDefault()	获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
          forEach()	对 hashMap 中的每个映射执行指定的操作。
          entrySet()	返回 hashMap 中所有映射项的集合集合视图。
          keySet()	返回 hashMap 中所有 key 组成的集合视图。
          values()	返回 hashMap 中存在的所有 value 值。
          merge()	添加键值对到 hashMap 中
          compute()	对 hashMap 中指定 key 的值进行重新计算
          computeIfAbsent()	对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
          computeIfPresent()	对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

• 集合算法：框架中定义了几种算法，为集合类的静态方法。尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

  • 迭代器Iterator：用于遍历Collection对象的方法。

    • 获取迭代器

    Iterator<T> it = Collection.iterator();
    //T 为需要迭代的对象中的元素类型
    /*
    	常用方法
    */
    
    it.next();//返回下一个元素，更新迭代器状态
    it.hasnext();//用于检测集合中是否还有元素
    it.remove();//迭代器返回的元素删除。。

  • HashMap迭代：

  /* 三种常用方法 */
  
  //第一种，for语句循环keySet函数的返回值
  for(Integer a : map1.keySet()){
              System.out.println("key = " + a + " value = " + map1.get(a));
          }
  
  //第二种，创建entrySet的迭代器，entrySet函数返回Map的试图集合，集合元素类型为Map<T,E>
  Iterator<Map.Entry<Integer,String>> it = map1.entrySet().iterator();
          while(it.hasNext()){
              Map.Entry<Integer,String> entry = it.next();
              System.out.println("key = " + entry.getKey() + " value = " + entry.getValue());
          }
  
  //第三种，很大时：直接使用for循环entrySet的返回值
   for (Map.Entry<Integer,String> entry:map1.entrySet()){
              System.out.println("key = " + entry.getKey() + " value = " + entry.getValue());
          }

• 任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。