异常，常用类，包装类，字符串String,StringBuer和StringBuilde的区别

异常

异常：广泛地说异常就是所有的非正常情况。狭义来讲，就是jdk提供给我们的一些类

错误：程序有问题

​ 语法错误->写的代码有语法错误 -> 编译都不同过，根本运行不了

​ 逻辑错误->思想有问题

程序有异常我们是可以处理掉的

Throwable -> 是所有异常的基类；

​ Error -> 处理不了 不管了 比如内存溢出

​ Exception -> 异常

​ RuntimeException -> 运行时异常（编译没有问题，运行可能有问题） ->能通过判断解决 直接通过程序的健壮性解决

​ CheckedException -> 编译时异常（编译的时候就会有问题，必须要处理）-> 异常语法处理

RuntimeException 运行时异常

编译没有任何问题，但是运行的时候会有问题（异常）

我们需要处理，但是不会通过异常类处理。通过程序的健壮性处理（if判断）

异常的产生

在程序中出现了检查时异常，而别人又没有处理，向外抛出，所以我作为使用者，就必须要处理

异常处理的方法|方式

抛

简单的方式， 继续向外抛

throws -> 抛出

public void test()throws XXException{
    
}

我这个方法中有问题，有XXException异常，我没处理，交给你处理

特点:简单，但是从出现异常的地方开始，其后所有的代码将不再执行， 回到调用者那个地方继续

抓|捕获

比较麻烦，自己去处理，自己内部消化了，不需要告诉调用者

try-> 尝试 ： 这里是可能出现异常的代码 我需要对其进行检测

catch -> 捕获 ：给定一些异常的情况，如果现在出现了这个异常，就归我处理

finally -> 最终： 不管是否出现了异常， 我都会做收尾工作

try{
    待检查|可能出异常的代码
}catch(异常类型1 e){
    当出现了异常类型1的异常的时候， 我要进行的处理
}catch(异常类型2 e){
    当出现了异常类型2的异常的时候， 我要进行的处理
}...finally{
    一定会执行的代码
}

异常就是程序出问题了

1、语法错误 -> 你手的问题，根本编译不了，你必须改正

2、逻辑错误-> 你逻辑的问题，能编译能运行，但是结果不对 , 自己检查

3、系统的错误 -> 系统会崩溃， 程序能编译，运行一定会出问题，这个问题我们解决不了

4、运行时异常 -> 编译没有问题，但是运行有可能会出问题， 可以避免， 通过代码的健壮性避免了就可以了

5、检查时异常-> 编译就有问题，是因为我们不确定什么时候会有这个问题，编译就给我们机会可以处理

​ 抛：throws 向外抛出异常 throws 检查时异常，方法的头部，参数列表的括号和方法体括号之间

​ 抓：try,catch, finally

try{
    你觉得可能出现异常的代码；
    你觉得可能出现异常的代码；
}catch(检查时异常的类型 e){
    处理代码；
}...finally{
    收尾的语句;
}

先执行trye ->从上到下执行

如果一旦遇到异常，就从异常的那个地方跳到对应的catch

然后执行catch中的代码，刚才出现异常的那个地方的后面的代码就没有机会执行

catch中的代码执行结束之后，直接继续执行finally中的代码

finally执行结束之后，程序恢复正常，继续往下执行

如果try中没有异常出现，try当中的代码完整执行，然后跳过所有的catch，直接执行finally,然后正常往下走

throw -> 声明异常, 创建一个异常

可以自定义一个异常类，可以设定一些规则，如果他们违背你可以给他们抛出异常。

public class TestException {
    public static void main(String[] args) throws MyException {
       test();

    }

    // opr 就是你操作类型  +  -  *  /
    public static void test(String opr)throws MyException{
        int a = 10;
        int b = 20;
        if("+".equals(opr)){
            // 异常产生了  声明异常
            throw new MyException("+");
        }

        System.out.println(a + opr + b);
    }




}

/**
 /*
 自定义的异常类
 规定自己异常出现的场景，什么样的操作是异常，为了后面声明异常用
 如果你做加法 对我来说就是一个异常

 */

class MyException extends Exception{

    public MyException(String msg){
        super(msg);

    }

    public void tese(){
        System.out.println("你做了加法运算");
      }

}

常用类

Object类位于java.lang包中，java.lang包包含着Java基础和核心的类，在编译时会 自动导入；Object类是所有Java类的根基类，如果在类的声明中未使用extends关 键字指明其基类，则默认基类为Object类

public class Person{
    如果没有声明继承继承的父类，那么会默认继承Object类
}相当于
public class Person extends Object{}

Object也给我们提供了一些我们经常用的方法

像equals方法 和toString 方法我们经常用的，还有一个Clong方法

clone 方法用来让虚拟机帮我们创建一个当前对象的副本。是 Object 类提供， 所以所有的类，都具有这个方法，但是这个方法在Object中是受保护的，所以我们 需要重写，并且放开权限。
如果一个类，你希望能够被克隆，这个类必须要实现一个接口 Cloneable 。
1、重写 clone() 方法， 具有克隆的能力
2、实现 Cloneable 接口， 具有克隆的权利

3，因为Clong是Object类的方法如果我们在调用克隆到现在类的时候就会发生向下转型的问题，所以我们要把Object转成我们所需要的的类型就行。

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
     A a = new A(10);
        System.out.println(a);
        System.out.println(a.getA());
        A a1 = (A) a.clone();
        System.out.println(a1);
        System.out.println(a1.getA());

    }
}



class A implements Cloneable{
  private  int a;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

//  @Override
//    public Object clone() throws CloneNotSupportedException {
//      return super.clone();
//  }

    public A(int a) {
        this.a = a;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
}

包装类

包装类就是作者在设计类的时候为每个基本数据类型设计了一个对应的类进行代表，这种和八种数据类型对象的类，我们就可以称为包装类

包装类除了 Integer 和 Character 类以后，其它六个类的类名和基本 数据类型一直，只是类名的第一个字母大写即可。

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

包装类的格式其实跟我们创建对象的时候一样。都是new出来的对象在进行操作。

JDK5的新特性

• 自动装箱：把基本类型转换为包装类类型

• Integer i = 100;//自动转成包装类型
  

• 自动拆箱：把包装类类型转换为基本类型

  Integer i=100;//包装类型
  ii+=100;//自动转换成基本类型；
  

  注意事项；

  在使用时，Integer x = null;代码就会出现NullPointerException。

  建议先判断是否为null，然后再使用

缓存

自动装箱拆箱时，对于-128,127之间的值,编译器仍然会把它当做基本类型处理。

  // 系统默认创建了256个 byte的类型的对象  放入byte数组里面 只要不超过byte区间就不会改变。
        Integer i = new Integer(100);
        Integer ii1 = new Integer(100);
         i=100;//拿到同一个值
        ii1=100;//拿到的是同一个值

字符串相关类

String类

String是一个不可变的字符序列（字符串）

我们可以通过不同的形式构建String的对象，常见的是字符串常量的形式，直接 使用一对 “” 即可，也可以通过构造器的方式，还可以通过字符数组和字节数组的 形式来构建；

String 可以被new对象出来， 也可以不用new对象 用""来表示。

String常用的一些方法

String中有一个方法 length() , 返回|获取字符串中的字符个数

  String str = "abcd我你她";
        System.out.println(str.length());//获取字符串的长度
   

String类的下述方法能创建并返回一个新的String对象： concat, replace, substring, toLowerCase, toUpperCase, trim

 public static void main(String[] args) {
        String str1 = new String("abc");
        String str2 = "abc";
        String str3 = "abc";
        System.out.println(str3==str2);

        System.out.println(str1.equals(str2));

        String str = "123";
        String s1 = str.concat("abc");  // 将abc拼接到 123后面

        System.out.println(str);
        System.out.println(s1);


        str = "137-2856-7719";
        s1 = str.replace("-","");// 替换，  将-替换成''
        System.out.println(str);
        System.out.println(s1);

        str = "你好挫";
        str1 = str.substring(2); // 从下标为2 地方开始截取字符串到末尾
        System.out.println(str1);

        str1 = str.substring(0,2);  // [)  从开始的位置截取字符串，到指定的位置结束，但是不包括戒指位置
        System.out.println(str1);


        str = "selECt";
        str1 = str.toUpperCase();
        System.out.println(str1);

        str1 = str.toLowerCase();
        System.out.println(str1);

        str = "  里 里 张   ";
        System.out.println("===" + str + "===");
        str1 = str.trim();  // 去掉字符串两端的空格
        System.out.println("===" + str1 + "===");

    }

提供查找功能的有关方法: endsWith, startsWith, indexOf,，lastIndexOf

    查找的一系列方法
 */
public class Demo005 {
    public static void main(String[] args) {
        String str = "abcd我你她";
        System.out.println(str.length());

        str = "abc.jpg.txt";
        if(str.endsWith("jpg")){  // 判断是否以指定的 字符串结尾
            System.out.println("上传成功");
        }else{
            System.out.println("不好意思，格式不对");
        }


        String name = "廖张阿三";
        if(name.startsWith("廖")){  // 判断是否以什么开始
            System.out.println("我们是本家");
        }else{
            System.out.println("离我远点");
        }

提供比较功能的方法: equals, equalsIgnoreCase, compareTo

public class Demo007 {
    public static void main(String[] args) {
        String str = "abC";
        // 判断str是否为null
        System.out.println(str == null);

        // 判断str是否是空字符串""
        System.out.println("".equals(str));
        // 判断str内容是否是abc
        System.out.println("abc".equals(str));

        // 判断str内容是否是abc不区分大小写
        System.out.println("abc".equalsIgnoreCase(str));


        char c = str.charAt(2);
        System.out.println(c);


    }
}

StringBuer和StringBuilde

StringBuer和StringBuilder非常类似，均代表可变的字符序列，而且方法也一样。 (StringBuilder被设计用作 StringBuer 的一个简易替换，建议优先采用该类，因为 在大多数实现中，它比 StringBuer 要快。)

下面是一些StringBuffer的一些方法的使用

    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();   // ""
        System.out.println(sb1);
        StringBuffer sb2 = new StringBuffer("abc"); // “abc”
        System.out.println(sb2);

        sb2.append("123");
        System.out.println(sb2);

        sb2 = new StringBuffer("abcdefghijklmn");
        System.out.println(sb2);
        sb2.delete(3,5);  // 删除字符串中的指定的内容   左闭右开
        System.out.println(sb2);

        sb2.deleteCharAt(10);  // 删除指定位置的字符
        System.out.println(sb2);

        sb2.insert(5,"AAAA");  // 在指定位置插入数据
        System.out.println(sb2);

        sb2.setCharAt(5,'Z');
        System.out.println(sb2);

        sb2.reverse();
        System.out.println(sb2);

    }

• StringBuffer类概述

  • 通过JDK提供的API，查看StringBuffer类的说明
  • 线程安全的可变字符序列

• B:StringBuffer和String的区别

  • String是一个不可变的字符序列
  • StringBuffer是一个可变的字符序列

• StringBuffer的构造方法：

  • public StringBuffer():无参构造方法
  • public StringBuffer(int capacity):指定容量的字符串缓冲区对象
  • public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

• StringBuffer的方法：

  • public int capacity()：返回当前容量。 理论值(不掌握)
  • public int length():返回长度（字符数）。 实际值

StringBuffer的添加功能

• public StringBuffer append(String str):
  • 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
• public StringBuffer insert(int offset,String str):
  • 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

StringBuffer的删除功能

• public StringBuffer deleteCharAt(int index):
  • 删除指定位置的字符，并返回本身
• public StringBuffer delete(int start,int end):
  • 删除从指定位置开始指定位置结束的内容，并返回本身

StringBuffer的替换功能

• public StringBuffer replace(int start,int end,String str):

  • 从start开始到end用str替换

• B:StringBuffer的反转功能

  • public StringBuffer reverse():
    • 字符串反转

StringBuffer的截取功能

• public String substring(int start):

  • 从指定位置截取到末尾

• public String substring(int start,int end):

  • 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

• 注意事项

  • 注意:返回值类型不再是StringBuffer本身

String,StringBuer和StringBuilde的区别

String：不可变字符序列 StringBuer：可变字符序列，并且线程安全，但是效率低 StringBuilder：可变字符序列，线程不安全，但是效率高（一般用StringBuilder)

如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中， 降低效率。如果这样的操作放到循环中，会极大影响程序的性能。
相反，StringBuer类是对原字符串本身操作的，可以对字符串进行修改而不产生副 本拷贝。可以在循环中使用