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类似