Java基础加强（面向对象、集合、常见API、异常、泛型）

面向对象

• 类与对象的理解

  类的理解 类是对现实生活中一类具有共同属性和行为的事物的抽象 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合 简单理解：类就是对现实事物的一种描述

  类和对象的关系 类：类是对现实生活中一类具有共同属性和行为的事物的抽象 对象：是能够看得到摸的着的真实存在的实体 简单理解：类是对事物的一种描述，对象则为具体存在的事物

• 成员变量和局部变量的区别

  1、类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上） 2、内存中位置不同：成员变量（堆内存）局部变量（栈内存） 3、生命周期不同：成员变量（随对象的存在而存在，随对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失） 4、初始化值不同：成员变量（有默认的初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

• 封装

  • 概述

    是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部 的，外界是无法直接操作的

  • 原则

    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法

  • 好处

    通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

• 继承

  • 继承概述

    继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

  • 好处

    1、提高了代码的复用性 2、提高了代码的维护性 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

  • 弊端

    类的耦合性增强，父类发生变化，子类实时不得不跟着变化，削弱了子类的独立性

  • 访问特点

    • 变量

      就近原则： 1、子类局部范围找； 2、子类成员范围找； 3、父类成员范围找； 4、如果没有就报错；

    • 方法

      • 构造方法

        注意： 1、子类中所有的构造方法默认都会访问父类中无参的构造方法 2、子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类的初始化，原因是，每一个子类构造方法的第一条语句默认都是：super(); 3、如果父类中没有无参构造，a、通过使用super关键字去显示的调用父类的有参构造。b、在父类中自己提供一个无参构造方法（推荐使用）

      • 成员方法

        通过子类对象访问一个方法 1、子类成员范围找； 2、父类成员范围找； 3、如果都没有就报错。

  • 方法重写

    在子类中出现了和父类一模一样的方法声明，方法名一样，参数列表也一样。前提条件是继承。 当子类需要父类的功能，而功能主体子类有自己特有的类容，可以重写父类中的方法，这样既沿袭了父类的功能，又定义了子类特有的内容。 @Override（用来检测当前方法，是否是重写方法） 注： 1、私有方法不能被重写（私有成员不能被继承）； 2、子类方法权限必须【大于等于】父类方法的权限（public >protected> 默认（什么都不写，留空） > private） 3、子类方法的返回值必须【小于等于】父类方法的返回值范围。

• 多态

  • 多态概述

    什么是多态： ​ 同一个对象，在不同时刻表现出来的不同形态 多态的前提： 1、要有继承或实现关系 2、要有方法的重写 3、要有父类引用指向子类对象

  • 好处

    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。

  • 弊端

    不能使用子类的特有成员

  • 访问特点

    成员变量： 编译看父类，运行看父类 成员方法： 编译看父类，运行看子类

  • 多态的转型

    向上转型： 父类引用指向子类对象就是向上转型 向下转型： 格式：子类型 对象名 = (子类型)父类引用;

• 抽象类

  • 抽象类概述

    当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！ ​ 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

  • 抽象类特点

    抽象类和抽象方法必须使用 abstract 关键字修饰

    格式： //抽象类的定义 public abstract class 类名 {}

    //抽象方法的定义 public abstract void eat();

        抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

    抽象类不能实例化： ​ 抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态。 抽象类不能创建对象。

    抽象类的子类： ​ 1、要么重写抽象类中的所有抽象方法 ​ 2、要么是抽象类

    • 变量

      1、既可以是变量 2、也可以是常量

    • 方法

      构造方法: 1、空参构造 2、有参构造 供子类创建对象时，初始化成员使用的。 成员方法： 1、抽象方法 2、普通方法

• 接口

  • 接口概述

    接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。 ​ Java中的接口更多的体现在对行为的抽象！

  • 接口的组成及特点

    接口用关键字interface修饰 public interface 接口名 {}

    类实现接口用implements表示 public class 类名 implements 接口名 {}

    接口不能实例化 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。 ​ 多态的形式：具体类多态，抽象类多态，接口多态。 接口的子类 ​ 1、要么重写接口中的所有抽象方法 ​ 2、要么子类也是抽象类

    • 变量

      成员变量 只能是常量 ​ 默认修饰符：public static final

    • 方法

      构造方法 ​ 没有，因为接口主要是扩展功能的，而没有具体存在

      成员方法 ​ 只能是抽象方法 ​ 默认修饰符：public abstract

      注： JDK8可以定义static静态方法 格式： [public] static 返回值类型 方法名称（参数列表）{方法体} 注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。

      JDK8可以定义default默认方法 格式： [public] default 返回值类型 方法名称（参数列表）{方法体} 注意：默认方法也可以被覆盖重写，重写的时候去掉default关键字

      JDK9可以定义private私有方法 格式： private 返回值类型 方法名称（参数列表）{方法体} private static 返回值类型 方法名称（参数列表）{方法体} 注意：private的方法只有自己才能调用，不能被实现类或别人使用。默认方法可以调用私有的静态方法和非静态方法。静态方法只能调用私有的静态方法

  • 使用接口的注意事项

    使用接口的时候，需要注意： 1、接口没有静态代码块或者构造方法 2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。 3、如果实现所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。 4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。 5、如果实现类实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。 6、一个类如果直接父类当中的方法，和接口中的默认方法产生了冲突，优先用父类当中的方法。

    接口与接口之间多继承的注意事项： 1、多个父接口当中的抽象方法如果重复，没有关系。 2、多个父接口当中的默认方法，如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。

• 抽象类和接口的区别

  成员区别： 抽象类：变量,常量；有构造方法；有抽象方法，也有非抽象方法 接口：常量；抽象方法

  关系区别： 类与类：继承，单继承 类与接口：实现，可以单实现，也可以多实现。 接口与接口：继承，单继承，多继承

  设计理念区别： 抽象类：对类抽象，包括属性、行为 接口：对行为抽象，主要是行为

• 类和接口的关系

  类与类： 继承关系，只能单继承，但是可以多层继承 类与接口的关系： 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口 接口与接口的关系： 继承关系，可以单继承，也可以多继承

• 内部类

  内部类可以直接访问外部类的成员，包括私有，外部类要访问内部类的成员，不写创建对象。

  • 成员内部类

    如果一个类定义在成员位置，就是成员内部类。 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

    • 格式

      修饰符 class 外部类名称{ 修饰符 class 内部类名称{ } } 注意： 内用外，随意访问；外用内，需要内部类对象。

    • 使用

      1、间接方式：在外部类的方法中，使用内部类，然后main只是调用外部类的方法。 2、直接方式： 公式： 类名称 对象名 = new 类名称();（在外部类里面访问自己的内部类） 【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】（访问不到私有（private）修饰的内部类）

  • 局部内部类

    如果一个类定义在一个方法内部的，那么这就是一个局部内部类。

    • 格式

      修饰符 class 外部类名称{ 修饰符 返回值类型 外部类名称(参数列表){ （没有修饰符）class 局部类名称{ } } }

    • 使用

      只有当前所属的方法才能使用它，出了这个方法外面就不能用。在jdk8时，系统会默认给内部类访问的局部变量前加final。 该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

  • 匿名内部类

    如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。 本质： 是一个继承了该类或实现了该接口的子类匿名对象。

    • 格式

      接口名称 对象名 = new 接口名称(){ //覆盖重写所有抽象方法 }; 格式解析： 1、new代表创建对象的动作 2、接口名称就是匿名内部类需要实现哪个接口 3、{...}是匿名内部类的内容 注意： 匿名内部类，在创建的时候，只能使用一次。

    • 使用

      匿名内部类可以通过多态的形式接收。 格式： Inter i = new Inter(){ @Override /重写方法 }; i.方法名(); 直接调用： new 接口名(){ //重写的接口里面的方法 }.接口里面的方法名(); 匿名内部类在开发中的使用： 当泛型某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码。

常见API

• String

  • 特点

    1、字符串不可变，它们的值在创建后不能被更改 2、虽然 String 的值是不可变的，但是它们可以被共享 3、字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

  • 常用构造方法

    public String() 创建一个空白字符串对象，不含有任何内容 public String(char[] chs) 根据字符数组的内容，来创建字符串对象 public String(byte[] bys) 根据字节数组的内容，来创建字符串对象 String s ="abc"; 直接赋值的方式创建字符串对象，内容就是abc

  • 常用方法

    public boolean equals(Object anObject) 比较字符串的内容，严格区分大小写(用户名 和密码) public char charAt(int index) 返回指定索引处的 char 值 public int length() 返回此字符串的长度

  • 创建字符串对象两种方式的区别

    通过构造方法创建 ​ 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相 同，但是地址值不同

    直接赋值方式创建 ​以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中 出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

  • 字符串的比较

    • ==号

      比较基本数据类型：比较的是具体的值 比较引用数据类型：比较的是对象地址值

    • equals方法

      public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写

• StringBuilder类

  StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变 指的是 StringBuilder 对象中的内容是可变的

  • 常用构造方法

    public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容 public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象

  • 常用方法

    public StringBuilder append(任意类型) 添加数据，并返回对象本身 public StringBuilder reverse() 返回相反的字符序列 public StringBuilder append (任 意类型) 添加数据，并返回对象本身 public StringBuilder reverse() 返回相反的字符序列 public int length() 返回长度，实际存储值 public String toString() 通过toString()就可以实现把StringBuilder转 换为String

  • String类与StringBuilder类

    • 区别

      String类内容是不可变的； StringBuilder类内容是可变的

    • 相互转换

      StringBuilder转换为String public String toString() 通过toString()就可以实现把StringBuilder转换为String

      String转换为StringBuilder public StringBuilder(String s) 通过构造方法就可以实现把String转换为StringBuilder

• Math

  • 求绝对值

    //public static int abs(int a);返回绝对值 System.out.println(Math.abs(-10));//10 System.out.println(Math.abs(10));//10

  • 向上取整

    //public static double ceil(double a);返回大于或等于参数的最小double值(向上取整) System.out.println(Math.ceil(12.34));//13.0 System.out.println(Math.ceil(15.56));//16.0

  • 向下取整

    //public static double floor(double a);返回小于或等于参数的最大double值（向下取整） System.out.println(Math.floor(12.34)); System.out.println(Math.floor(15.56));

  • 四舍五入

    //public static int round(float a);按照【四舍五入】返回最接近参数的int System.out.println(Math.round(12.34)); System.out.println(Math.round(15.56));

  • 返回较大值

    //public static int max(int a,int b);返回两个int值中较大值 System.out.println(Math.max(12,13));

  • 返回较小值

    //public static int min(int a,int b);返回两个int值中较小值 System.out.println(Math.min(12,13));

  • 幂

    //public static double pow(double a,double b);返回a的b次幂的值 System.out.println(Math.pow(2.0,3.0));

  • 随机小数[0,1.0)

    //public static double random();返回值为double的正值，[0,1.0) //System.out.println(Math.random()); System.out.println((int)(Math.random()*100+1));

• System

  • public static void exit(int status)

  • public static long currentTimeMillis()

• Object类的toString

  以良好的格式，更方便的展示对象中的属性值。

• Object类的equals方法

  作用：用于对象之间的比较，返回true或者false的结果（不希望比较地址值时，要对其进行重写）。

• Arrays包含用于操作数组的各种方法

  • 常用方法

    public static String toString(int[] a)返回指定数组的内容发字符串表示形式 public static void sort(int[] a)按照数组顺序排列指定的数组

  • 工具类设计思想

    1、构造方法用private修饰 2、成员用public static修饰

• 包装类（常用）

  • 常用构造方法

    public Integer(int value) 根据 int 值创建 Integer 对象(过时) public Integer(String s) 根据 String 值创建 Integer 对象(过时) public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例 public static Integer valueOf(String s) 返回一个保存指定值的 Integer 对象 String

  • Integer与String转换

    int转换为String 1、直接在数字后面加一个空字符串。 int number = 100; String s1 = number + ""; 2、通过String静态方法valueOf() int num = 100; String s = String.valueOf(num);

  • 自动装箱和自动拆箱

    自动装箱 把基本数据类型转换为对应的包装类类型 自动拆箱 把包装类类型转换为对应的基本数据类型

• 时间日期类

  • Date类

    Date代表了一个特定的时间，精确到毫秒

    • 常用构造方法

      public Date() 分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒 public Date(long date) 分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

    • 常用方法

      public long getTime() 获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值 public void setTime(long time) 设置时间，给的是毫秒值

  • SimpleDateFormat类

    SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。 我们重点学习日期格式化和解析

    • 常用构造方法

      public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式 public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat使用给定的模式和默认的日期格式

    • 常用方法

      格式化(从Date到String) public final String format(Date date)：将日期格式化成日期/时间字符串 解析从String到Date public Date parse(String sourcr)： 从给定字符串的开始解析文本以生产日期

    • 代码示例

      public class SimpleDateFormatDemo {    public static void main(String[] args) throws ParseException {        //格式化：从 Date 到 String        Date d = new Date(); //       SimpleDateFormat sdf = new SimpleDateFormat();        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");        String s = sdf.format(d);        System.out.println(s);        System.out.println("--------");

             //从 String 到 Date        String ss = "2048-08-09 11:11:11";        //ParseException        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        Date dd = sdf2.parse(ss);        System.out.println(dd);   } }

  • Calender类

    Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法 Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。 该方法返回一个Calendar 对象。 其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();

    • 常用方法

      public int get(int field) 返回给定日历字段的值 public abstract void add(int field, int amount) 根据日历的规则，将指定的时间量添加或减去给定的日历字段 public final void set(int year,int month,int date) 设置当前日历的年月日

Throwable异常

• Error

  严重问题，不需要处理

• Exception

  称为异常类，它表示程序本身可以处理的问题

  • 非RuntimeException（编译时异常）

    编译期就必须处理的，否则程序不能通过编译，就更不能正常运行。必须显示处理，否则程序就会发生错误，无法通过编译

  • RuntimeException处理（运行时异常）

    在编译期是不检查的，出问题后，需要我们回来修改代码。无需显示处理，也可以和编译时异常一样处理

  • 异常处理

    • JVM默认异常处理

      如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：1、 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台 2、程序停止执行

    • throws方式处理异常

      用在方法声明后面，跟的是异常类名，表示抛出异常，有该方法的调用者来处理，表示出现异常的一种可能性，并不一定会发生这些异常。 注意事项： 1、这个throws格式是跟在方法的括号后面的 2、编译时异常必须要进行处理，两种处理方案：try...catch …或者 throws，如果采用 throws 这种方案， 将来谁调用谁处理 3、运行时异常可以不处理，出现问题后，需要我们回来修改代码

    • throw

      throw关键字，用在方法体内，跟的是异常类名，表示抛出异常，由方法体内的语句处理，执行throw一定是抛出了某种异常。

    • try-catch方式处理异常

      格式： try{ 可能出现异常的代码; }catch(异常类名 变量名){ 异常的处理代码; }

      • try...catch...finally

        除非调用system.exit()让程序退出也就是将调用这个程序的进程断开了退出了这个程序就不会执行或断电等因素致使程序停止进程终止，否则无论任何因素finally块都一定会执行。

      • 执行流程

        1、程序从 try 里面的代码开始执行 2、出现异常，就会跳转到对应的 catch 里面去执行 3、执行完毕之后，程序还可以继续往下执行

    • 自定义异常处理

      自定义异常类 public class ScoreException extends Exception{ public ScoreException (){} public ScoreException (String message){ super(message); } }

          老师类

      public class Teacher{ public void checkScore(int score ) throws ScoreException{ if(score < 0 || score > 100){ throw new ScoreException("您输入的分数超出范围0~100"); }else{ System.out.println("成绩正常"); } } }

          测试类

      public class Demo { public static void main (String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入分数："); int score = sc.nexInt(); Teacher t = new Teacher(); try{ t.checkScore(score); }catch{ e.printStackTrace(); } } }

    • throws和throw的区别

      throws 1、用在方法声明后面，跟的是异常类名 2、表示抛出异常，由该方法的调用者来处理 3、表示出现异常的一种可能性，并不一定会发生这些异常 throw 1、用在方法体内，跟的是异常对象名 2、表示抛出异常，由方法体内的语句处理 3、执行throw一定抛出了某种异常

• 常用方法

  public String getMessage() 返回此 throwable 的详细消息字符串 public String toString() 返回此可抛出的简短描述 public void printStackTrace() 把异常的错误信息输出在控制台

集合

• 集合概述

  提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

• Collection（单列）

  是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

  • Collection常用方法

    boolean add(E e) 添加元素 boolean remove(Object o) 从集合中移除指定的元素 void clear() 清空集合中的元素 boolean contains(Object o) 判断集合中是否存在指定的元素 boolean isEmpty() 判断集合是否为空 int size() 集合的长度，也就是集合中元素的个数

  • List（可重复）

    List集合概述： 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元 素，并搜索列表中的元素。 与Set集合不同，列表通常允许重复的元素。 List集合特点： 1、有索引 2、可以存储重复元素 3、元素存取有序

    • 特有方法

      void add(int index,E element) 在此集合中的指定位置插入指定的元素。 E remove(int index) 删除指定索引处的元素，返回被删除的元素。 E set(int index,E element) 修改指定索引处的元素，返回被修改的元素。 E get(int index) 返回指定索引处的元素。

    • ArrrayList集合

      底层数据结构是数组，查询快，增删慢

      • 常用构造方法

        public ArrayList() 创建一个空的集合对象

      • 常用成员方法

        public boolean remove(Object o) 删除指定的元素，返回删除是否成功 public E remove(int index) 删除指定索引处的元素，返回被删除的元 素 public E set(int index,E element) 修改指定索引处的元素，返回被修改的元 素 public E get(int index) 返回指定索引处的元素 public int size() 返回集合中的元素的个数 public boolean add(E e) 将指定的元素追加到此集合的末尾 public void add(int index,E element) 在此集合中的指定位置插入指定的元素

    • LinkedList集合

      底层数据结构是链表，查询慢，增删快。

      • 特有方法

        public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定的元素追加到此列表的末尾。 public E getFirst() 返回此列表中的第一个元素。 public E getLast() 返回此列表中的最后一个元素。 public E removeFirst() 从此列表中删除并返回第一个元素。 public E removeLast() 从此列表中删除并返回最后一个元素。

    • ...

  • Set（不可重复）

    Set集合特点： 1、不包含重复元素的集合， 2、没有索引的方法，所以不能使用普通for循环遍历 3、存取顺序不保证

    • 哈希值

      哈希值简介： 是JDK根据对象的地址或者字符串或者实在算出来的int类型的数值。 如何获取哈希值： Object类中有一个方法可以获取对象的哈希值：public int hashCode();返回对象的哈希码值。 哈希值的特点： 同一个对象多次调用hashCode()方法返回的哈希值是相同的 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同。

    • HashSet

      HashSet集合的特点： 底层数据结构是哈希表。 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致 没有带索引的方法，所以不能使用普通for循环遍历。 由于是Set集合，所以是不包含重复元素的集合 。

      HashSet集合保证元素唯一性的原理 1.根据对象的哈希值计算存储位置 如果当前位置没有元素则直接存入 如果当前位置有元素存在，则进入第二步 2.当前元素的元素和已经存在的元素比较哈希值 如果哈希值不同，则将当前元素进行存储 如果哈希值相同，则进入第三步 3.通过equals()方法比较两个元素的内容 如果内容不相同，则将当前元素进行存储 如果内容相同，则不存储当前元素

      • LinkedHashSet

        LinkedHashSet集合特点： 哈希表和链表实现的Set接口，具有可预测的迭代次序。 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的. 由哈希表保证元素唯一，也就是说没有重复的元素 。

    • TreeSet

      集合概述和特点： 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法。 TreeSet()：根据其元素的自然排序进行排序 。 TreeSet(Comparator comparator) ：根据指定的比较器进行排序。 没有带索引的方法，所以不能使用普通for循环遍历。 由于是Set集合，所以不包含重复元素的集合 。

      • Comparator比较器排序

        用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

      • Comparable自然排序

        用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的。 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写。

• Map（双列）

  格式： interface Map<K,V> （K：键的类型；V：值的类型） Map集合的特点： 键值对映射关系 一个键对应一个值 键不能重复，值可以重复 元素存取无序

  • Map常用方法

    基本功能： V put(K key,V value) 添加元素 V remove(Object key) 根据键删除键值对元素 void clear() 移除所有的键值对元素 boolean containsKey(Object key) 判断集合是否包含指定的键 boolean containsValue(Object value) 判断集合是否包含指定的值 boolean isEmpty() 判断集合是否为空 int size() 集合的长度，也就是集合中键值对的个数

    获取功能： V get(Object key) 根据键获取值 Set keySet() 获取所有键的集合 Collection values() 获取所有值的集合 Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合

  • Map集合的遍历

    方案一： 获取所有键的集合。 用keySet()方法实现。 遍历键的集合，获取到每一个键 用增强for实现。 根据键去找值。 用get(Object key)方法实现 。

    方法二： 获取所有键值对对象的集合 Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合 遍历键值对对象的集合，得到每一个键值对对象 用增强for实现，得到每一个Map.Entry 根据键值对对象获取键和值 用getKey()得到键 用getValue()得到值

  • HashMap

  • ...

• Collections集合工具类

  是针对集合类的工具类

  • Collections常用方法

    public static void sort(List list) 将指定的列表按升序排序 public static void reverse(List<?> list) 反转指定列表中元素的顺序 public static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表

• 数据结构

  • 数组和链表

    特点： 数组结构：查询快，增删慢； 链表结构：查询慢，增删快；

  • 栈和队列

    特点： 栈结构：先进后出； 队列结构：先进先出；

• 迭代器

  迭代器，集合的专用遍历方式 Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的 Collection集合的遍历。 代码示例： public class IteratorDemo {    public static void main(String[] args) {        //创建集合对象        Collection<String> c = new ArrayList<>();

         //添加元素        c.add("hello");        c.add("world");        c.add("java");        c.add("javaee");

         //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到        Iterator<String> it = c.iterator();

         //用while循环改进元素的判断和获取        while (it.hasNext()) {            String s = it.next();            System.out.println(s);       }   } }

  • 增强for循环

    格式： for(元素数据类型 变量名 : 数组/集合对象名){ 循环体; }

  • 并发修改异常

    出现的原因 ： 迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际 修改值不一致，则会出现：ConcurrentModificationException 解决的方案： 用for循环遍历，然后用集合对象做对应的操作即可

泛型

泛型概述： 是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型 它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称 为泛型类、泛型方法、泛型接口

好处： 1、把运行时期的问题提前到了编译时期 2、避免了强制类型转换

• 泛型类

  • 格式

    修饰符 class 类名<类型>{} public class Generic<T>{}

• 泛型方法

  • 格式

    修饰符<类型> 返回值类型 方法名(类型 变量名){} public<T> void Generic(T t){}

• 泛型接口

  • 格式

    修饰符 interface 接口名<类型>{} public interface Generic<T>{ void show(T t); }

• 类型通配符

  • 格式

    类型通配符：<?> List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中 类型通配符上限：<? extends 类型> List<? extends Number>：它表示的类型是Number或者其子类型 类型通配符下限：<? super 类型> List<? super Number>：它表示的类型是Number或者其父类型

• 可变参数

  可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了 。

  • 格式

    修饰符 返回值类型 方法名(数据类型… 变量名) { }

    可变参数的注意事项： 这里的变量其实是一个数组 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

  • 使用

    Arrays工具类中有一个静态方法： public static List asList(T... a)：返回由指定数组支持的固定大小的列表 返回的集合不能做增删操作，可以做修改操作 List接口中有一个静态方法： public static List of(E... elements)：返回包含任意数量元素的不可变列表 返回的集合不能做增删改操作 Set接口中有一个静态方法： public static Set of(E... elements) ：返回一个包含任意数量元素的不可变集合 在给元素的时候，不能给重复的元素 返回的集合不能做增删操作，没有修改的方法