Java异常类+常用类+容器，泛型

捕获异常类

在Java中，要捕获异常类，通常使用try-catch块来捕获可能会抛出异常的代码。在try块中编写可能会抛出异常的代码，然后在catch块中捕获并处理异常。以下是一个简单的示例，演示如何捕获异常类：

public class Main {
public static void main(String[] args) {
try {
int[] numbers = {1, 2, 3};
System.out.println(numbers[4]); // 试图访问数组中索引为4的元素，会抛出ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Caught ArrayIndexOutOfBoundsException: " + e.getMessage());
}
}
}

在上面的示例中，我们尝试访问一个数组中索引为4的元素，这会导致数组越界异常(ArrayIndexOutOfBoundsException)。在try块中尝试访问数组元素，然后在catch块中捕获ArrayIndexOutOfBoundsException，并输出异常信息。

这样，我们可以在程序中捕获并处理各种可能出现的异常情况，以保证程序的稳定性和健壮性。注意，可以在一个try块中捕获多种类型的异常，也可以使用多个catch块分别处理不同的异常类型。

抛出异常类

在Java中，可以使用关键字throw来抛出异常类。通过抛出异常类，可以在程序中明确指示出某种异常情况，并在调用处进一步处理或传递异常。以下是一个简单的示例，演示如何抛出异常类：

public class Main {
public static void main(String[] args) {
try {
int age = -5;
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative");
}
} catch (IllegalArgumentException e) {
System.out.println("Caught IllegalArgumentException: " + e.getMessage());
}
}
}

在上面的示例中，我们定义了一个age变量，初始化为-5。然后在if语句中检查age的值是否为负数，如果是负数，则抛出IllegalArgumentException异常，并传递提示消息"Age cannot be negative"。在try块中抛出异常后，在对应的catch块中捕获并处理该异常。在这里，我们捕获了IllegalArgumentException异常，并输出其消息。

通过抛出异常类，我们可以在程序中主动引发异常情况，以便更好地控制程序流程和错误处理。同时，抛出异常类也可以使代码更具有清晰和可读性。

自定义异常类

在Java中，我们可以通过继承Exception或RuntimeException类来创建自定义的异常类。自定义异常类通常用于在特定情况下抛出自定义的异常，以便更好地描述和处理特定的异常情况。

以下是一个简单的示例，演示如何创建自定义的异常类：

public class CustomException extends Exception {
public CustomException() {
super("This is a custom exception");
}
public CustomException(String message) {
super(message);
}
public CustomException(String message, Throwable cause) {
super(message, cause);
}
}

在上面的示例中，我们定义了一个名为CustomException的自定义异常类，它继承自Exception类。我们提供了多个构造函数，以便在创建异常对象时可以传入不同的信息和原因。

包装类

在Java中，包装类（Wrapper Class）是用来把基本数据类型转换为对象的类。Java为每个基本数据类型提供了对应的包装类，这些包装类提供了一些方法和属性来操作基本数据类型。

以下是Java的基本数据类型及其对应的包装类：

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

这些包装类提供了方便的方法来进行基本数据类型和对象之间的转换，以及执行各种操作，比如比较、类型转换和数学运算等。

public class Main {
public static void main(String[] args) {
// 使用包装类创建对象并赋值
Integer num1 = new Integer(10);
Integer num2 = Integer.valueOf(20);
// 获取基本数据类型值
int value1 = num1.intValue();
int value2 = num2;
// 进行数学运算
int sum = num1 + num2;
// 使用包装类提供的静态方法
boolean result = Boolean.parseBoolean("true");
// 装箱（Boxing）和拆箱（Unboxing）
Integer num3 = 30; // 装箱操作
int value3 = num3; // 拆箱操作
}
}

通过包装类，我们可以很方便地对基本数据类型进行操作，并在需要时将其转换为对象。包装类在Java中非常常用，特别是在与集合类、泛型、反射和异常处理等相关的操作中。

String

在Java中，String、StringBuffer和StringBuilder都是用来处理字符串的类，它们之间有一些区别和适用场景。

1.String类：

• String是Java中的不可变字符串类，一旦创建就无法修改其值。
• 当我们对一个String对象进行修改操作时，实际上是创建了一个新的String对象，原有对象不会受影响。
• 由于String是不可变的，所以在涉及频繁的字符串操作时会产生大量的临时对象，效率较低。
• 常用于表示固定不变的字符串，例如字符串常量、配置文件等。

String str = "hello";
str = str + "world"; // 创建了一个新的String对象，原有对象没有改变

2.StringBuffer类：

• StringBuffer是可变的字符串类，支持对字符串的修改和操作。
• StringBuffer是线程安全的，适合在多线程环境下使用。
• 使用append()、insert()等方法可以在原有字符串上进行增删改操作，不会产生新的对象。
• 由于线程安全的实现，StringBuffer的性能比StringBuilder略差。

StringBuffer sb = new StringBuffer("hello");
sb.append("world"); // 在原有对象上修改，没有创建新的对象

3.StringBuilder类：

• StringBuilder是可变的字符串类，与StringBuffer类似，但不是线程安全的。
• StringBuilder比StringBuffer效率更高，适合在单线程环境下使用。
• 使用append()、insert()等方法可以在原有字符串上进行增删改操作，不会产生新的对象。

StringBuilder sb = new StringBuilder("hello");
sb.append("world"); // 在原有对象上修改，没有创建新的对象

总体来说，如果在单线程环境下进行频繁的字符串操作，推荐使用StringBuilder，因为它的效率更高；如果在多线程环境下进行字符串操作，或者需要线程安全的操作，建议使用StringBuffer。而String则适合表示不变的字符串常量。

BigDecimal

在Java中，BigDecimal类是用来表示任意精度的浮点数的类，用于解决浮点数运算可能出现的精度问题。BigDecimal类提供了高精度的算术运算方法，可以有效避免由于浮点数计算精度导致的精度丢失和计算错误。

以下是BigDecimal类的一些重要特点和用法：

1.创建BigDecimal对象：
可以使用BigDecimal类的构造方法来创建对象，也可以使用静态方法valueOf()来创建BigDecimal对象。

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = BigDecimal.valueOf(20.5);

2.精度控制：
BigDecimal类允许指定精度，包括精确度和保留位数，以便更好地控制计算精度。

BigDecimal num3 = new BigDecimal("10.12345").setScale(2, RoundingMode.HALF_UP);

3.算术运算：
BigDecimal类支持基本的算术运算，如加减乘除，并提供方法来进行高精度的计算

BigDecimal result = num1.add(num2);
BigDecimal result2 = num1.multiply(num2);

4.比较大小：
BigDecimal类也提供了比较大小的方法，可以方便地比较两个BigDecimal对象的大小

int compareResult = num1.compareTo(num2);

5.使用场景：
BigDecimal常用于金融领域、科学计算等对精度要求较高的场景，特别是处理货币金额、税率等需要精确计算的数据。

总的来说，BigDecimal类提供了一种可靠且高精度的方案，可以有效避免浮点数运算可能出现的精度问题，是处理精确计算和精度要求高的场景的最佳选择。

泛型简介

泛型（Generics）是Java语言中一种强大的特性，允许在代码中使用类型参数，使得代码可以更加灵活、可重用和类型安全。泛型可以在编译时提供类型检查和类型安全性，并减少了强制类型转换的需求。

以下是Java中泛型的一些基本概念和用法：

1.泛型类：
通过在类名后面使用尖括号（<>）来定义泛型类，其中尖括号中填写类型参数。

public class Box {
private T value;
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}

2.泛型方法：
可以在方法中使用泛型，类似于泛型类的定义方式。

public T getFirstElement(List list) {
return list.get(0);
}

3.通配符：
通配符（Wildcard）可以在泛型中表示未知类型。通配符有三种形式：?、? extends T、? super T，分别表示任意类型、某种类型的子类和某种类型的父类。

public void processElements(List<?> list) {
for (Object element : list) {
// do something with element
}
}

4.泛型限定：
可以使用泛型限定来限制泛型类型参数的范围，比如只允许特定类型或其子类作为类型参数。

public void printNumber(T number) {
System.out.println(number);
}

5.类型擦除：
Java中的泛型是通过类型擦除来实现的，编译器在编译时会擦除泛型信息，将泛型类型参数替换为Object。这意味着泛型类型信息在运行时是不可用的。

泛型是Java中的一个重要特性，可以提高代码的灵活性和可读性，同时也可以提供编译时的类型检查和类型安全性。通过合理使用泛型，可以编写更加通用、可复用和安全的代码。

列表

在Java中，列表（List）是一种常用的数据结构，用于存储一组有序的元素。Java中的列表接口是java.util.List，它是一个接口，常用的实现类有ArrayList、LinkedList和Vector等。

以下是Java中列表的一些特点和常用方法：

1.列表的创建：
可以使用ArrayList、LinkedList等实现List接口的类来创建列表对象，如下所示：

List list = new ArrayList<>();

2.添加元素：
可以使用add()方法向列表中添加元素，可以根据索引位置添加元素，也可以在尾部添加元素。

list.add("Java");
list.add(1, "Programming");

3.获取元素：
可以使用get()方法根据索引获取列表中的元素。

String element = list.get(0);

4.删除元素：
可以使用remove()方法根据索引或元素值删除列表中的元素。

list.remove(0);
list.remove("Java");

5.遍历列表：
可以使用增强的for循环或迭代器来遍历列表中的元素。

for(String element : list) {
System.out.println(element);
}

Iterator iterator = list.iterator();
while(iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}

6.列表的大小：
可以使用size()方法获取列表中元素的个数。

int size = list.size();

7.其他常用方法：
除了上述方法，List接口还提供了其他一些常用方法，如contains()判断列表中是否包含某个元素、indexOf()获取元素在列表中的索引位置、clear()清空列表等。

列表是一个非常常用的数据结构，在Java的集合框架中占据重要的位置。通过合理使用列表，可以方便地操作和管理一组有序的元素，提高代码的灵活性和可读性。

set

在Java中，Set是一种集合（Collection）接口，它代表了一组不重复元素的集合。Set接口继承自Collection接口，是一种不允许有重复元素的集合。Java中的Set接口没有提供额外的添加重复元素的方法，当尝试向Set中添加重复元素时，添加操作会被忽略。

Java提供了几种常用的Set实现类，如HashSet、TreeSet和LinkedHashSet等。以下是关于Java中Set的一些特点和常用方法：

1.创建Set对象：
可以使用HashSet、TreeSet等Set接口的实现类来创建一个Set对象。例如：

Set hashSet = new HashSet<>();

2.添加元素：
可以使用add()方法向Set中添加元素，如果Set中已经存在相同的元素，则添加操作会被忽略。

hashSet.add("Java");
hashSet.add("Python");
hashSet.add("Java"); // 重复元素，添加操作会被忽略

3.删除元素：
可以使用remove()方法从Set中删除指定元素。

hashSet.remove("Python");

4.遍历Set：
可以使用增强的for循环或迭代器来遍历Set中的元素。

for(String element : hashSet) {
System.out.println(element);
}

Iterator iterator = hashSet.iterator();
while(iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}

6.其他常用方法：
Set接口还提供了其他一些常用方法，如contains()判断Set中是否包含某个元素、isEmpty()判断Set是否为空、size()获取Set的大小等。

boolean containsJava = hashSet.contains("Java");
int size = hashSet.size();

Set是一种非常有用的数据结构，适用于需要存储不重复元素的场景。使用Set可以避免重复元素的问题，提高程序的效率和可读性。在Java中，Set接口及其实现类为开发人员提供了一种方便、高效的不重复元素集合管理方式。

map

在Java中，Map是一种集合（Collection）接口，用于存储键值对（key-value pairs）的数据结构。每个键对应一个值，键是唯一的，可以通过键来获取对应的值。Java中的Map接口定义了键和值之间的映射关系，常用的实现类包括HashMap、TreeMap和LinkedHashMap等。

以下是关于Java中Map的一些特点和常用方法：

1.创建Map对象：
可以使用HashMap、TreeMap等Map接口的实现类来创建一个Map对象。例如：

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

2.添加键值对：
可以使用put()方法向Map中添加键值对。

hashMap.put("Java", 1);
hashMap.put("Python", 2);

3.获取值：
可以使用get()方法根据键来获取对应的值。

int value = hashMap.get("Java");

4.删除键值对：
可以使用remove()方法根据键来删除对应的键值对。

hashMap.remove("Python");

5.遍历Map：
可以通过entrySet()方法获取Map中的所有键值对，然后使用增强的for循环或迭代器遍历。

for(Map.Entry<String, Integer> entry : hashMap.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

Iterator<Map.Entry<String, Integer>> iterator = hashMap.entrySet().iterator();
while(iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

6.其他常用方法：
Map接口还提供了其他一些常用方法，如containsKey()判断Map是否包含某个键、containsValue()判断Map是否包含某个值、keySet()获取所有键的集合、values()获取所有值的集合等。

boolean containsKey = hashMap.containsKey("Java");
Collection values = hashMap.values();

Map是一种键值对映射的数据结构，在Java中被广泛应用。使用Map可以方便地存储和查找键值对，提高程序的效率和可读性。通过合理使用Map，开发人员可以更高效地处理需要键值对映射的情况，使程序设计更加灵活。