蓝旭春季培训第二周预习博客（Java异常类+常用类+容器、泛型）

异常类

Java异常类是Java编程语言中用于处理异常情况的类。异常是在程序执行过程中发生的错误或异常情况，它可能导致程序无法正常执行。Java异常类提供了一种机制，可以捕获和处理这些异常，以便程序能够继续执行或进行适当的处理。Java中的异常类都是Throwable类的子类，主要分为两类：Error和Exception。
Exception异常是可以捕获和处理的。

捕获

使用try-catch语句来捕获异常

try {
             System.out.println("请输入你朋友的姓名：");
             String name= scanner.nextLine();
             fr.setName(name);
             System.out.println("请输入你朋友的年龄：");
             String ageStr=scanner.nextLine();
             int age = Integer.parseInt(ageStr);
             fr.setAge(age);
             break;
            }catch(NumberFormatException e){
                e.printStackTrace();
            }
            catch (AgeOutBoundsException e){
                e.printStackTrace();
            }
                catch(NameFormatException e){
                e.printStackTrace();
            }

抛出

用throw关键字抛出异常，在方法内部将异常抛给调用者去处理。

  public void setName(String name) {
        if(name.length()>10||name.length()<3){
            throw new NameFormatException(name+"名字格式有误");
        }
        this.name = name;
    }

自定义异常类

让java中的异常更符合实际使用场景。
要继承父类Exception。

package test1;

public class NameFormatException extends RuntimeException{
    public NameFormatException() {
    }

    public NameFormatException(String message) {
        super(message);
    }
}

常用类

包装类

在Java中，包装类（Wrapper Classes）是八种基本数据类型（byte, short, int, long, float, double, boolean, char）的对应类。这些类为每种基本数据类型提供了一种对象形式，使得基本数据类型可以被当作对象来处理。包装类主要用于集合框架（Collections Framework），因为集合框架只接受对象作为元素，不接受基本数据类型。

八种基本数据类型及其对应的包装类：

byte-> Byte
short ->Short
int ->Integer
long ->Long
float ->Float
double -> Double
boolean ->Boolean
char ->Character

1.自动装箱和拆箱

Integer num = 10;
int primitiveNum = num;

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

int num = 10;
String str = Integer.toString(num);

3.将字符串解析为基本数据类型

String str = '10';
int num = integer.parseInt(str);

4.标包装类对象

Integer a = 1;
Integer b = 2;
if(a==b){
sout;
//比较的是引用
}
if（a.equals(b)){
sout;
//比较的是值
}

String类（buffer，builder）

String buffer和String builder类定义可变字符串序列，用法相似。
常用操作
append():添加字符串到末尾；
reverse():将字符串反转；
length():返回字符串的长度

package test2;

public class Test {
    public static void main(String[] args) {
        // 创建一个新的StringBuilder对象
        StringBuilder builder = new StringBuilder("kunkun");

        // 使用append方法添加文本
        builder.append(" 502");
        System.out.println(builder.toString());

        // 使用insert方法在指定位置插入文本
        builder.insert(6, " Beautiful");
        System.out.println(builder.toString()); 

        // 使用delete方法删除指定位置的字符
        builder.deleteCharAt(6);
        System.out.println(builder.toString());

        // 使用replace方法替换指定位置的字符
        builder.replace(11, 15, "iful Java");
        System.out.println(builder.toString());

        // 获取StringBuilder的长度
        int length = builder.length();
        System.out.println("Length of StringBuilder: " + length); 
    }
}

输出结果：

kunkun 502
kunkun Beautiful 502
kunkunBeautiful 502
kunkunBeautiful Java 502
Length of StringBuilder: 24

String buffer和String builder的区别

StringBuffer是线程安全的，因为它内部的方法使用了synchronized关键字来确保在多线程环境中操作的原子性。然而，如果单线程环境中需要频繁地操作字符串，使用StringBuilder类通常会有更好的性能，因为StringBuilder不是线程安全的，它避免了不必要的同步开销

BigDecimal

BigDecimal是Math包下的精确运算浮点数的一个类。
常用方法

package test2;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Test {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("10.0");
        BigDecimal bd2 = new BigDecimal("5.5");
        //加法
        BigDecimal bd3=bd1.add(bd2);
        System.out.println(bd3);
        //减法
        BigDecimal bd4=bd1.subtract(bd2);
        System.out.println(bd4);
        //乘法
        BigDecimal bd5=bd1.multiply(bd2);
        System.out.println(bd5);
        //除法
        BigDecimal bd6=bd1.divide(bd2,2, RoundingMode.HALF_DOWN);
        System.out.println(bd6);
        //比较大小
        int result=bd1.compareTo(bd2);
        if(result>0){
            System.out.println("bd1>bd2");
        } else if (result<0) {
            System.out.println("bd2>bd1");
        }else {
            System.out.println("bd1=bd2");
        }
    }
}

运行结果

15.5
4.5
55.00
1.82
bd1>bd2

泛型

泛型指的是能接受任何种类的对象并处理的特性。泛型主要有以下两个作用：
● 适用于多种数据类型执行相同的代码（代码复用）
● 泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

泛型类

public class Box<T> {  //Box是泛型类，T是泛型参数类型
    private T t;  
  
    public void set(T t) {  
        this.t = t;  
    }  
  
    public T get() {  
        return t;  
    }  
}

package test2;

public class test {
    public static void main(String[] args) {
        Box<Integer> integerBox=new Box<>();
        integerBox.set(10);
        Integer value=integerBox.get();
        System.out.println(value);
        Box<String>stringBox=new Box<>();
        stringBox.set("kunkun");
        String str=stringBox.get();
        System.out.println(str);
    }
}

泛型接口

package test2;

public interface Generator<T> {
    T process(T input);
}


//----------------------------
package test2;

import java.util.Locale;

public class StringProcess implements Generator<String>{
    @Override
    public String process(String input) {
        return input.toUpperCase();
    }

}
//-------------------------------

package test2;

public class test {
    public static void main(String[] args) {
        Generator<String> processor=new StringProcess();
        String result =processor.process("kunkun");
        System.out.println(result);
    }
}

运行结果

KUNKUN

泛型方法

package test2;

public class Generator {
    public static <T> void process(T[]array){
        for(T element:array){
            System.out.println(element+" ");
        }
        System.out.println();
    }
}

package test2;

public class test {
    public static void main(String[] args) {
        String [] str={"kunkun","篮球","唱跳"};
        Generator.process(str);
    }
}

运行结果

kunkun
篮球
唱跳

容器

Java容器是Java集合框架的一部分，用于存储和管理对象集合。Java容器类主要包括List、Set、Queue和Map等接口以及它们的实现类。

List

1.ArrayList
*ArrayList是最常用的列表实现类之一，它基于数组实现，因此具有较快的随机访问速度。
*适用于需要频繁访问列表元素，但不经常进行插入或删除操作的场景。
2.LinkedList
*LinkedList基于链表实现，因此插入和删除操作较快，但随机访问速度较慢。
*适用于需要频繁进行插入或删除操作的场景。
3.Vector
*Vector是早期Java版本中提供的列表实现类，与ArrayList类似，但它是线程安全的（同步的）。
*由于同步操作带来的性能开销，现在通常不推荐使用Vector，除非确实需要线程安全。

package test2;

import java.util.ArrayList;
import java.util.List;

public class test {
    public static void main(String[] args) {
        List<String> inventory = new ArrayList<>();

        //添加元素
        inventory.add("坤坤");
        inventory.add("篮球");
        inventory.add("唱跳");

        //获取元素
        String result = inventory.get(1);
        System.out.println(result);

        //删除元素
        inventory.remove("唱跳");

        //修改元素
        inventory.set(1,"basketball");

        //获取列表大小
        int size=inventory.size();
        System.out.println(size);

        //遍历列表
        for(String element:inventory){

            System.out.println(element);
        }
    }
}

运行结果：

篮球
2
坤坤
basketball

set

在Java中，Set是一个接口，它继承自Collection接口，表示一个不包含重复元素的集合。Set接口的实现类通常用于存储唯一元素的集合，其中元素的顺序可能不重要（例如HashSet），或者元素的插入顺序会被保留（例如LinkedHashSet），或者元素会根据它们的自然顺序或者创建Set时提供的Comparator进行排序（例如TreeSet）。

1.HashSet
基于哈希表实现，提供快速的插入和查找操作。
元素的迭代顺序可能不是按照它们被插入的顺序。
不保证元素的顺序。
2.LinkedHashSet
基于哈希表和链表实现，使用链表维护元素的插入顺序。
在迭代时，元素会按照它们被插入到集合中的顺序出现。
性能略低于HashSet，因为需要维护双向链表。
3.TreeSet
基于红黑树实现，元素自然有序或根据创建Set时提供的Comparator进行排序。
在迭代时，元素会按照它们的自然顺序或比较器的顺序出现。
插入、删除和查找操作的时间复杂度为O(log n)。
用法与List类似

map

在Java中，Map是一个接口，它用于存储键值对（key-value pairs）的集合。Map不允许出现重复的键，每个键最多映射到一个值。Map接口提供了许多用于插入键值对、获取值、检查键或值是否存在以及删除键值对等操作的方法。

1.HashMap
基于哈希表实现，提供快速的插入和查找操作。
键和值都可以是null（最多一个键为null，但可以有多个值为null的键值对）。
不保证映射的顺序，特别是它不保证该顺序恒久不变。
2.LinkedHashMap
是HashMap的一个子类，它维护了一个运行于所有条目的双向链表。此链表定义了迭代顺序，通常是按照将条目插入到映射中的顺序（插入顺序）。
性能略低于HashMap，因为它需要维护双向链表。
迭代时，元素会按照它们被插入到映射中的顺序出现，或者根据访问顺序排序（如果构造时指定了accessOrder为true）。
3.TreeMap
基于红黑树实现，键自然有序或根据创建Map时提供的Comparator进行排序。
提供了对键的排序功能，因此它可以根据键的顺序或者自然顺序（如果没有提供比较器）返回排序后的键-值对。
插入、删除和查找操作的时间复杂度为O(log n)。
键不可以是null，但值可以是null。
4.Hashtable
是Map接口的一个古老实现，是线程安全的，但通常不推荐使用，因为同步操作带来的性能开销较大。
键和值都不可以是null
用法与List类似