JavaSE面试重点基础易错点总结3

目录

异常处理

异常分类

异常类的继承关系

异常继承树

自定义异常类型

JAVA API

JAVA常用包

Object类

public　boolean　equals(Object　obj)

public　int　hashCode()

public　String　toString()

包装类

基本数据类型包装类

基本类型与包装类之间的转换

字符串与基本数据类型、包装类型转换

字符串类

String对象的创建

String中的常用方法

StringBuffer和StringBuilder类

Date类中常用方法

Date类的常用方法

Calender类

SimpleDateFormat类的使用

集合框架

Java 中集合类框架

List接口及其实现类

ArrayList类

LinkedList实现类

Set接口及其实现类

Map接口及其实现类

泛型

泛型变量的类型限定

---

异常处理

异常分类

1. 语法错误
2. 逻辑错误
3. 异常（预见可能会发生，但是无法完全避免）

异常类的继承关系

异常继承树

1. Throwable类描述了所有被虚拟机抛出的非正常状况。处在异常类层次结构的顶层，有两个子类Error、Exception。

2. Error类特指应用程序在运行期间发生的严重错误，没有必要使用异常处理机制处理Error

3. Exception类是所有异常类的父类，其下面有几十个子类，描述了不同类型的异常。又分为非检查性异常和检查性异常。

   1. 以RuntimeException为代表的一些类，称为非检查性异常（unchecked Exception）也成为运行时异常，用来表示设计或实现方面的问题，如数组下标越界、除数为零等问题。因为设计和实现正确的程序不会引发这类异常，所以Java并不强制提前处理它。

   2. 以IOException为代表的一些类为检查性异常（checked Exception）也成为非运行时异常。所谓的检查和非检查是指编译器在编译时是否检查。如果代码中存在检查性异常，必须进行异常处理，否则编译时不能通过。

   3. 异常处理机制

      1. 异常处理过程

         1. 过程：

            1. 发出异常报告--产生异常类对象--封装异常事件信息后提交给运行时系统--终止当前运行，专项异常处理。

         2. 方式：

            1. 自行处理：try/catch/finally语句

               1. try{
                      可能会出现异常的语句
                  }catch(XXXException e){ 对出现异常的情况进行处理}finally{  最终块，可选}

               2. 注意：

                  1. catch块，是用来捕获并处理try块抛出的异常的代码块。没有try块，catch块不能单独存在。我们可以有多个catch块，以捕获不同类型的异常
                  2. 如果程序抛出多个不同类型的异常，我们需要多个catch()语句来处理
                  3. 和特殊异常类相关联的catch()块必须写在和普通异常类相关联的catch()之前
                  4. try{…}和catch( ){…}之间不可以添加任何代码
                  5. try、catch、finally都不可以单独使用，一个try可以有多个catch，catch和finally必须与try联合使用
                  6. 不能利用异常处理来进行程序的分支处理，它只是处理非正常情况的一种机制。

            2. 回避异常：使用throws声明抛出异常

               1. throws关键词语法：

                  1. throws位置：方法参数列表的后面
                  2. throws关键字后面，可以跟多个异常，中间用逗号分割
                  3. throws关键字声明的异常，由调用该方法的方法处理。
               2. throw关键词语法：
                  1. throw 异常实例
                  2. throw语句后不允许有其他语句，因为这些语句没有机会执行

自定义异常类型

1. 异常类结构基本上是相似的，而且基本上都是使用ex.getMessage()、ex.getStackTrace()、ex.printStackTrace()等方法获得异常信息。

2. 当在标准库中找不到恰当的异常类时，可以自定义异常类

   1. 语法：public class  MyException extends Exception{
          
      }

   2. 特点：自定义异常类型的使用方法与类库提供的异常类使用方法一致

JAVA API

JAVA常用包

1. java.lang：Java语言包, 该包中提供了利用Java语言进行程序设计的基础类，比如String、Math、System类，该包中的类不需要使用import语句进行导入，都会被自动导入。
2. java.util：该包中主要包含一些实用的工具类，比如集合框架类、日期处理类、字符串解析类、随机数生成类等。
3. java.awt：该包中主要包含处理用户界面和绘制图形图像的各种类。
4. java.io：该包中主要包含处理输入、输出编程的各种类。
5. java.net：该包中主要包含处理网络编程的各种类。
6. java.sql：该包中主要包含处理数据库编程的各种类。

Object类

所有类的祖先类，Java语言中唯一一个没有父类的类。

public　boolean　equals(Object　obj)

1. 作用：
   1. 未重写的情况下，比较两个引用所指向对象的地址是否相等
   2. 根据类的特性重写后，根据要求判断是否为同一个对象。可能在实际的栈内存中引用不同，不为同一个对象，但是对类来说是同一对象。

public　int　hashCode()

1. 特点：

   1. 任何一个对象的默认的哈希码是将对象的内存地址通过某种转换得到的，所以不同对象会有不同的哈希码。

   2. 一个代表对象的十六进制整数，好比对象的身份证号。

   3. 多次执行同一个程序，因操作系统的运行情况不一样，内存使用情况也不一样，程序所获得的内存不同，这就导致同一个对象的哈希码也不一定相同。

   4. 覆盖equals()方法同时，建议覆盖hashCode()方法。

2. hashcode的实现，要满足的特征：

   1. 自反性：即对任意一个非空的指引值x，x.equals(x)永远返回true。

   2. 对称性：即对任意两个非空的指引值x，y，如果x.equals(y)返回true，那么y.equals(x)也返回true。

   3. 传递性：当x.equals(y)返回true并且y.equals(z)返回true时，x.equals(z)也返回true。

public　String　toString()

1. 作用：返回对象的字符串表示

包装类

作用：让基本数据类型的这些数据也具有面向对象的特性

基本数据类型包装类

1.  包装类：

   基本类型	包装类
   boolean	Boolean
   byte	Byte
   char	Character
   double	Double
   float	Float
   int	Integer
   long	Long
   short	Short

2. 特点：基本数据类型的变量没有默认值，包装类型的变量默认值为null
3. 作用：

   1. 作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

   2. 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

基本类型与包装类之间的转换

1. int和Integer类之间的转换
   1. int　n　=　10;
      Integer　in　=　new　Integer(n);//将int类型转换为Integer类型
      int　m　=　in.intValue();//将Integer类型的对象转换为int类型

2. Integer类内部的常用方法

   1. parseInt方法：

      1. int　n　=　Integer.parseInt(s)：将数字字符串转换为int数值；

      2. public　static　int　parseInt(String　s,　int　radix)：将字符串按照参数radix指定的进制转换为int

   2. toString方法

      1. public　static　String　toString(int　i)

         该方法的作用是将int类型转换为对应的String类型。

字符串与基本数据类型、包装类型转换

1. 包装类转换成字符串

   1. double d1=3.1415926; 

        Double d1 = new Double(d1); //生成Double类                                                              String sd1 = d1.toString();
   2. String myString = "" + myInt;

2. 字符串转换为基本数据类型

   1. String　myNumber　="1234";
      int　myInt　=　Integer.parseInt(myNumber);

字符串类

特点：1.不属于8种基本数据类型，而是一种引用类型，但是可以和使用基本数据类型一样直接赋值

           2.String对象代表一组不可改变的Unicode字符序列，String类对象的内容一旦被初始化就不能再改变，对它的任何修改实际上又产生一个新的字符串

           3.String类是final类型的类，不能被继承，所有的方法不允许被覆盖

String对象的创建

1. 实例化：
   1. 静态方法：
      1. 语法：String　s1　=　"abc";　 String　s2　=　"abc";　
      2. 特点：使用静态方式创建的字符串，如果前后两次创建的字符串内容相同，则在堆区的常量池中只会产生一个字符串对象，即两个引用指向同一块地址
      3. 注意：当使用"+"运算符进行运算时，如果参与运算的有字符串，则"+"的含义为进行字符串连接

   2. 动态方式：

      1. 语法：String　s3　=　new　String("abc"); String　s4　=　new　String("abc");

      2. 特点：不管前后两次创建的字符串内容是否相同，每创建一次，都会在堆内存中会产生出不同的对象，即两个引用指向不同的地址。

String中的常用方法

1. 求长度：public　int　length()  获取字符串中的字符的个数
2.   获取字符串中的字符：public　char　charAt(int　index)   获取字符串中的第index个字符，从0开始

3. 取子串：

   1. public　String　substring(int　beginIndex,int　endIndex)  获取从beginIndex　开始到endIndex-1　结束的子串，包括beginIndex，不包括endIndex。

   2. public　String　substring(int　beginIndex)  获取从beginIndex开始到结束的子串

4. 定位字符或者字符串：

   1. public　int　indexOf(int　ch)  定位参数所指定的字符

   2. public　int　indexOf(int　ch,int　index)   从index开始定位参数所指定的字符

   3. public　int　indexOf(String　str)  定位参数所指定的字符串

   4. public　int　indexOf(String　str,int　index)  从index开始定位str所指定的字符串

5. 替换字符和字符串：

   1. public　String　replace(char　c1,char　c2)  把字符串中的字符c1替换成字符c2，只替换一处

   2. public　String　replaceAll(String　s1,String　s2)  把字符串中出现的所有的s1替换成s2

   3. public　String　replaceFirst(String　s1,String　s2)  把字符串中的第一个s1替换成s2

6. 比较字符串内容：

   1. public　boolean　equals(Object　o)  比较字符串内容是否与参数相同，区分大小写

   2. public　boolean　equalsIgnoreCase(Object　o)    比较字符串内容是否与参数相同，不区分大小写

7. 大小写转换

   1. public　String　toUpperCase()  把字符串中的所有字符都转换成大写

   2. public　String　toLowerCase()  把字符串中的所有字符都转换成小写

8. 前缀和后缀

   1. public　boolean　startsWith(String　prefix)  字符串是否以参数指定的子串为前缀

   2. public　boolean　endsWith(String　suffix)  字符串是否以参数指定的子串为后缀

StringBuffer和StringBuilder类

在字符串的内容经常需要变动时使用。

StringBuilder和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问），但是StringBuilder 有速度优势

Date类中常用方法

Date类的常用方法

方法	含义
new Date（）	实例化Date对象，常见于获得系统当前时间
new Date（long time）	实例化Date对象，并根据具体的时间偏移量time设置时间
boolean　after(Date　when)	测试此日期是否在指定日期之后
boolean　before(Date　when)	测试此日期是否在指定日期之前
int　compareTo(Date　anotherDate)	比较两个日期的顺序。如果参数　Date　等于此　Date，则返回值　0；如果此　Date　在　Date　参数之前，则返回小于　0　的值；如果此　Date　在　Date　参数之后，则返回大于　0　的值。
boolean　equals(Object　obj)	比较两个日期的相等性。

        Date　now　=　new　Date();//获取当前系统时间
        System.out.println(now); //获取1970年1月1日1000毫秒之后的时间
        Date　d1　=　new　Date(1000);
        System.out.println(now.after(d1));
        System.out.println(now.before(d1));
        System.out.println(now.compareTo(d1));

Calender类

1. 使用Calendar类代表当前时间：Calendar c = Calendar.getInstance();

2. 使用Calendar类代表指定的时间：

   1. public　final　void　set(int year, int month, int date)

   2. public　void　set(int　field, int　value)

      在该方法中，参数field代表要设置的字段的类型，常见类型如下：

      Calendar.YEAR——年份

      Calendar.MONTH——月份

      Calendar.DATE——日期

      Calendar.DAY_OF_MONTH——日期，和上面的字段完全相同

      Calendar.HOUR——12小时制的小时数

      Calendar.HOUR_OF_DAY——24小时制的小时数

      Calendar.MINUTE——分钟

      Calendar.SECOND——秒

      Calendar.DAY_OF_WEEK——星期几

3. 获得Calendar对象中对应的信息：public　int　get(int　field)

4. add()方法：public　abstract　void　add(int　field,int　amount)  在Calendar对象中的某个字段上增加或减少一定的数值，增加时amount的值为正，减少时amount的值为负

5. after()方法：public　boolean　after(Object　when)  判断当前日期对象是否在when对象的后面，如果在when对象的后面则返回true，否则返回false

6. getTime()方法：public　final　Date　getTime()  Calendar类型的对象转换为对应的Date类对象    Calendar　c6　=　Calendar.getInstance();
               Date　d1　=　c6.getTime();

7. setTime()：public　final　void　setTime(Date　date)  是将Date对象转换为对应的Calendar对象

SimpleDateFormat类的使用

SimpleDateFormat使得可以选择任何用户定义的日期-时间格式的模式。

获取SimpleDateFormat的实例：

SimpleDateFormat　sdf=new　SimpleDateFormat("yyyy-MM-dd　HH:mm:ss");　

1. 字符串转日期：

   SimpleDateFormat　sdf=new　SimpleDateFormat("yyyy-MM-dd　HH:mm:ss");　　

   Date　date=sdf.parse("2002-10-8　15:30:22");　

2. 日期转字符串：

   SimpleDateFormat　sdf=new　SimpleDateFormat("yyyy年MM月dd日");　

   String　dateStr=sdf.format(new　Date());　

集合框架

Java 中集合类框架

集合与数组的区别：1.数组是容器，它的长度是固定的，不会自动扩充，数组中既可以存放基本数                                      据类型也能存放引用数据类型的引用。

                                 2.集合也是一种容器，它的长度是可变的，集合中只能存放引用数据类型的                                        引用

List接口及其实现类

List接口继承了Collection接口，用来包含一组有序有重复的对象。

1. 在指定的位置上添加元素

   1. public　void　add(int　index , Object　o)
          // 第一个参数表示要添加的元素的位置，从0开始。

   2. public　boolean　addAll(int　index , Collection　c)  
          //第一个参数表示位置，如果不指定位置，默认在最后添加。

2. 删除指定位置的元素：public Object remove(int index) // 参数用于指定要删除的元素的位置。

3. 获取某个元素或者获取某些元素：

   1.     //获取指定位置的元素。
      public　Object　get(int　index)    

   2.  //获取从fromIndex到toIndex这些元素，包括fromIndex，不包括toIndex。   
      public　List　subList(int　fromIndex,int　toIndex) 

4. 查找某个元素

   1. // ：查找元素在集合中第一次出现的位置，并返回这个位置，如果返回值为-1，表示没有找到这个元素。
      public　int　indexOf(Object　o) 

   2.     //：查找元素在集合中最后一次出现的位置。
      public　int　lastIndexOf(Object　o) 

5. 修改元素的方法：

   1. //用第二个参数指定的元素替换第一个参数指定位置上的元素。
      public　Object　set(int　index , Object　o)  

ArrayList类

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

1. 特点：

   1. ArrayList是一种动态的长度可自动变更的数组

   2. 可以通过泛型<T>限定加入到ArrayList中的元素类型，以保证加入指定类型的元素

   3. 使用无参构造方法实例化一个ArrayList对象，默认其初始长度为10

2. 构造方法：

   1. ArrayList() // 构造一个初始容量为10的空的链表；

   2. ArrayList(Collection< ?　extends　E>　c)  // 使用1个已经存在的集合构造一个链表，集合中的元素在新的链表中的顺序由集合的iterator()方法决定。

   3. ArrayList(int　initialCapacity)//构造一个由参数指定初始化空间大小的链表。

3. ArrayList类中的常用方法：

   1. 向ArrayList中添加对象：

      1. //在链表的最后添加参数指定的元素。
         public　boolean　add(Object　o)

      2. //第一个参数表示要添加的元素的位置，从0开始。
         public　void　add(int　index,Object　o)

      3. //在List对象最后添加参数指定的所有元素。
         public　boolean　addAll(Collection　c) 

      4. //第一个参数表示位置，如果不指定位置，默认在最后添加。
         public　boolean　addAll(int　index,Collection　c)

   2. 删除特定的元素：

      1. //参数用于指定要删除的元素的位置。
         public　Object　remove(int　index)

      2. //删除指定的某个元素。
         public　boolean　remove(Object　o)

      3. //删除指定的多个元素。
         public　boolean　removeAll(Collection　c)

      4. //只保留指定集合中存在的元素，其他的都删除，相当于取两个集合的交集。
         public　boolean　retainAll(Collection　c) 

      5. //删除所有的元素。
         public　void　clear()

   3. 获取某个元素或者获取某些元素：

      1. //获取指定位置的元素。
         public　Object　get(int　index)

      2. //获取从fromIndex到toIndex这些元素，包括fromIndex，不包括toIndex。
         public　List　subList(int　fromIndex,int　toIndex)

   4. 查找某个元素：

      1. //查找元素在集合中第一次出现的位置，并返回这个位置，如果返回值为-1，表示没有找到这个元素。
         public　int　indexOf(Object　o) 

      2. //查找元素在集合中最后一次出现的位置。
         public　int　lastIndexOf(Object　o)

      3. //用于判断集合是否是空的。
         public　boolean　isEmpty()

      4. // 判断是否包含指定元素
         public　boolean　contains(Object　o)

      5. //判断是否包含指定的多个元素。
         public　boolean　containsAll(Collection　c) 、

   5. 修改元素的方法：

      1. //用第二个参数指定的元素替换第一个参数指定位置上的元素。
         public　Object　set(int　index,Object　o)

   6. 转换成其它对象：

      1. ​​​​​​​//把所有元素都转换成有顺序的迭代器。
         public　ListIterator　listIterator()

      2. //从index开始的所有元素进行转换。
         public　ListIterator　listIterator(int　index) 

      3. //转换成迭代器，方便集合中元素的遍历。
         public　Iterator　iterator()

      4. //转换成数组，也是方便集合中元素的遍历。
         public　Object[]　toArray()

   7. 获取集合中元素的个数：

      1. //用于获取集合中元素的个数。
         public　int　size()

   8. ArrayList的遍历：

      1. ​​​​​​​ for(int　i=0;i<list1.size();i++){
              System.out.println(list1.get(i));
          }

      2.  Object　o[]　=　list1.toArray();
          for(int　i=0;i<o.length;i++){
              String　temp　=　(String)o[i];
              System.out.println(temp);
          }

      3.  Iterator　i　=　list1.iterator();
          while(i.hasNext()){
              String　temp　=　i.next();
              System.out.println(temp);
          }

      4. for(Object obj: collection){
         　　　statements;//要执行的语句
         }

LinkedList实现类

基于双向链表实现的List，插入删除效率高，但查找效率低（虽然有一个加速动作），容量可以自由扩充，不存在容量不足的问题

1. 构造方法：

   1. // 实例化一个空的列表
      LinkedList　l1　=　new　LinkedList()　;

   2. // 实例化一个列表，并使用c填充

      LinkedList　l1  =　new　LinkedList(Collection　c)　;

2. LinkedList类的方法包括ArrayList类中的方法，这部分同名的方法应用也基本一致

Set接口及其实现类

1. 与List相比的特点：
   1. 素不能重复
   2. 集合内的元素是无序的，不能根据下标去直接访问

2. HashSet类

   1. ​​​​​​​特点：

      1. 使用实现了Set接口，底层依赖了HashMap 对象
      2. 不能保证元素的排列顺序，顺序有可能发生变化
      3. HashSet不是同步的，如果多个线程同时访问一个Set，只要有一个线程修改Set中的值，就必须进行同步处理，通常通过同步封装这个Set的对象来完成同步，如果不存在这样的对象，可以使用Collections.synchronizedSet()方法完成。
      4. 最好在创建时使用语句 Set　s　=　Collections.synchronizedSet(new　HashSet(...)); 防止意外的对集合的非同步访问
      5. 元素值可以是null。

3. TreeSet类

   1. ​​​​​​​特点：

      1. 元素是按照升序排列的​​​​​​​

Map接口及其实现类

1. 特点：
   1. Map内存储的是“键/值对”, 这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象

   2. Map的每个元素包括两个部分：键（Key）和值（Value）

   3. 同一个Map对象中不允许使用相同的键，但是允许使用相同的值。

   4. Map接口隐含的有3个集合：键的集合、值的集合和映射的集合。

2. Map接口下常用的方法

   1. 添加元素的方法

      1. public　Object　put(Object　key,Object　value)

         第一个参数指定键，第二个参数指定值，如果键存在，则用新值覆盖原来的值，如果不存在添加该元素。

         public　void　putAll(Map　m)，添加所有参数指定的映射。

   2. 获取元素的方法

      1. public　Object　get(Object　key)

         获取指定键所对应的值，如果不存在，返回null。

   3. 删除元素的方法

      1. public　Object　remove(Object　key)

         根据指定的键删除元素，如果不存在该元素，返回null。

   4. 与键集合、值集合和映射集合相关的操作

      1. public　Set　entrySet() //获取映射的集合。

      2. public　Collection　values() //获取值的集合。

      3. public　Set　keySet() //返回所有键名的集合。

         这3个方法的返回值不一样，因为Map中的值是允许重复的，而键是不允许重复的，当然映射也不会重复。Set不允许重复，而Collection允许重复。

   5. 判断是否存在指定Key和Value的方法

      1. public　boolean　containsValue(Object　value) //判断是否存在值为value的映射。

      2. public　boolean　containsKey(Ojbect　key) //判断是否存在键为key的映射。

泛型

将原本确定不变的数据类型参数化：ArrayList<String>　al=new　ArrayList<String>();

1. 特点：
   1. 操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。

   2. 般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

泛型变量的类型限定

当类、接口或方法需要对泛型类型变量加以约束，只能默认T为原始类型Object。

        public static  <T extends Comparable> get(T t1,T t2){
    if(t1.compareTo(t2)>=0);
    return　t1;
}

注意：

1. 此处的 extends 其实并不表示继承，可以将其理解成“绑定”，“绑定”的可以是类，也可以是接口，表示 T 应该是绑定类型的子类型

2. 如果用一个类作为限定，则它必须是限定列表中的第一个，不同的限定类型之间用“ &” 分