Api与异常
Api与异常
Api概念与常用Api
应用编程接口 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
字符串的比较
== 比较引用数据类型：比较的是对象地址值
String类常见构造方法:
- public String() : 创建一个空白字符串对象，不含有任何内容
- public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
- public String(String original) : 根据传入的字符串内容，来创建字符串对象
- String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
注意:
String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址
而是该对象所记录的真实内容.
String类 : public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
String s1 = "abc";
String s2 = "ABC";
String s3 = "abc";
// equals : 比较字符串内容, 区分大小写
System.out.println(s1.equals(s2));
String类常用方法
String类常用方法:
-
public boolean equals(Object anObject) 比较字符串的内容，严格区分大小写
-
public boolean equalsIgnoreCase(String anotherString) 比较字符串的内容，忽略大小写
-
public int length() 返回此字符串的长度
-
public char charAt(int index) 返回指定索引处的 char 值
-
public char[] toCharArray() 将字符串拆分为字符数组后返回
-
public String substring(int beginIndex, int endIndex) 根据开始和结束索引进行截取，得到新的字符串（包含头，
不包含尾） -
public String substring(int beginIndex) 从传入的索引处截取，截取到末尾，得到新的字符串
-
public String replace(CharSequence target, CharSequence replacement) 使用新值，将字符串中的旧值替换，
得到新的字符串 -
public String[] split(String regex) 根据传入的规则切割字符串，得到字符串数组
示例代码 ：String类 截取substring String telString = sc.nextLine(); // 2. 截取字符串前三位 String start = telString.substring(0,3); // 3. 截取字符串后四位 String end = telString.substring(7); toCharArray // 2. 将字符串拆分为字符数组 char[] chars = s.toCharArray(); // 3. 遍历字符数组 for (int i = 0; i < chars.length; i++) { System.out.println(chars[i]); // replace替换敏感词 // 2. 替换敏感词 String result = s.replace("TMD","***"); split(String regex)切割字符串（返回字符串数组类型） String[] split(String regex) ：根据传入的字符串作为规则进行切割 将切割后的内容存入字符串数组中，并将 字符串数组返回 String stuInfo = sc.nextLine(); // stuInfo = "张三,23"; // 3. 根据逗号切割字符串，得到（张三）（23） String[] sArr = stuInfo.split(","); // System.out.println(sArr[0]); // System.out.println(sArr[1]); public char charAt(int index) 返回指定索引处的 char 值
StringBuilder类
StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的
StringBuilder常用方法
- public StringBuilder append(任意类型) 添加数据，并返回对象本身
- public StringBuilder reverse() 返回相反的字符序列
StringBuilder和String之间的相互转换
StringBuilder转换为String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
示例代码：
/*
//StringBuilder 转换为 String
StringBuilder sb = new StringBuilder();
sb.append("hello");
//String s = sb; //这个是错误的做法
//public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String s = sb.toString();
System.out.println(s);
*/
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
示例代码：
//String 转换为 StringBuilder
String s = "hello";
//StringBuilder sb = s; //这个是错误的做法
//public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
Math类
-
1、Math类概述
- Math 包含执行基本数字运算的方法
-
2、Math中方法的调用方式
- Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用
-
3、Math类的常用方法
System类
System类的常用方法
-
示例代码
- 需求：在控制台输出1-10000，计算这段代码执行了多少毫秒
public class SystemDemo { public static void main(String[] args) { // 获取开始的时间节点 long start = System.currentTimeMillis(); for (int i = 1; i <= 10000; i++) { System.out.println(i); } // 获取代码运行结束后的时间节点 long end = System.currentTimeMillis(); System.out.println("共耗时：" + (end - start) + "毫秒"); }}
Object类
-
Object类概述
- Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
-
查看方法源码的方式
- 选中方法，按下Ctrl + B
-
重写toString方法的方式
-
- Alt + Insert 选择toString
-
- 在类的空白区域，右键 -> Generate -> 选择toString
-
-
toString方法的作用：
-
以良好的格式，更方便的展示对象中的属性值
public static String toString(对象) | 返回参数中对象的字符串表示形式。 public static String toString(对象, 默认字符串)|返回对象的字符串表示形式。 对象如果不为空，打印对象调用toString，对象如果为空就打印默认字符串 | public static Boolean isNull(对象) | 判断对象是否为空 | public static Boolean nonNull(对象) | 判断对象是否不为空
-
BigDecimal
-
作用
可以用来进行精确计算
-
构造方法
-
常用方法
- 总结
- BigDecimal是用来进行精确计算的
- 创建BigDecimal的对象，构造方法使用参数类型为字符串的。
- 四则运算中的除法，如果除不尽请使用divide的三个参数的方法。
代码示例：
//String类型会精准，如果是double类型会有误差，因为小数转二进制再转十进制不准确
BigDecimal divide = bd1.divide(参与运算的对象,小数点后精确到多少位,舍入模式);
参数1 ，表示参与运算的BigDecimal 对象。
参数2 ，表示小数点后面精确到多少位
参数3 ，舍入模式
BigDecimal.ROUND_UP 进一法
BigDecimal.ROUND_FLOOR 去尾法
BigDecimal.ROUND_HALF_UP 四舍五入
BigDecimal b1 = new BigDecimal("0.1");
BigDecimal b2 = new BigDecimal("0.3");
//加法
BigDecimal sum = b1.add(b2);
System.out.println(sum);
//减法
BigDecimal res = b1.subtract(b2);
System.out.println(res);
//乘法
BigDecimal m = b1.multiply(b2);
System.out.println(m);
//除法
/* BigDecimal divide = b1.divide(b2);
System.out.println(divide);错误*/
BigDecimal d = b1.divide(b2,3,BigDecimal.ROUND_HALF_UP);
System.out.println(d);
包装类
基本类型包装类
-
基本类型包装类的作用
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换 -
基本类型对应的包装类
integer类
-
Integer类概述
包装一个对象中的原始类型 int 的值
-
Integer类构造方法
-
示例代码：
public class IntegerDemo {
public static void main(String[] args) {
//public Integer(int value)：根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(100);
System.out.println(i1);
//public Integer(String s)：根据 String 值创建 Integer 对象(过时)
Integer i2 = new Integer("100");
// Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("--------");
//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 String
Integer i4 = Integer.valueOf("100");
System.out.println(i4);
}
}
自动装箱 和 自动拆箱
-
自动装箱
把基本数据类型转换为对应的包装类类型
-
自动拆箱
把包装类类型转换为对应的基本数据类型
示例代码：
Integer i = 100; // 自动装箱
i += 200; // i = i + 200; i + 200 自动拆箱；i = i + 200; 是自动装箱
int转化为String
-
int转换为String
- 转换方式
- 方式一：直接在数字后加一个空字符串
- 方式二：通过String类静态方法valueOf()
示例代码：
public class IntegerDemo { public static void main(String[] args) { //int --- String int number = 100; //方式1 String s1 = number + ""; System.out.println(s1); //方式2 //public static String valueOf(int i) String s2 = String.valueOf(number); System.out.println(s2); System.out.println("--------"); } } - 转换方式
String转化为int
-
String转换为int
-
转换方式
- 方式一：先将字符串数字转成Integer调用valueOf()方法，再调用 public int intValue（Integer x）
- 方式二：通过Integer静态方法parseInt()进行转换
示例代码：
public class IntegerDemo { public static void main(String[] args) { //String --- int String s = "100"; //方式1： String --- Integer --- int Integer i = Integer.valueOf(s); //public int intValue() int x = i.intValue(); System.out.println(x); //方式2 //public static int parseInt(String s) int y = Integer.parseInt(s); System.out.println(y); } }
-
递归
-
递归的介绍
- 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
- 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
- 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
-
递归的基本使用
public class MyFactorialDemo2 { public static void main(String[] args) { int sum = getSum(100); System.out.println(sum); } private static int getSum(int i) { //1- 100之间的和 //100 + (1-99之间的和) // 99 + (1- 98之间的和) //.... //1 //方法的作用: 求 1- i 之间和 if(i == 1){ return 1; }else{ return i + getSum(i -1); } } }
递归的注意事项
- 递归一定要有出口。否则内存溢出
- 递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出
数组排序
二分查找
-
二分查找概述
查找指定元素在数组中的位置时,以前的方式是通过遍历,逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时,查找的效率很低
二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率
-
需求
在数组{1,2,3,4,5,6,7,8,9,10}中,查找某个元素的位置
-
实现步骤
- 定义两个变量，表示要查找的范围。默认min = 0 ，max = 最大索引
- 循环查找，但是min <= max
- 计算出mid的值
- 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
- 如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
- 如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
- 当min > max 时，表示要查找的元素在数组中不存在，返回-1.
-
代码实现
public class MyBinarySearchDemo { public static void main(String[] args) { int [] arr = {1,2,3,4,5,6,7,8,9,10}; int number = 11; //1,我现在要干嘛? --- 二分查找 //2.我干这件事情需要什么? --- 数组 元素 //3,我干完了,要不要把结果返回调用者 --- 把索引返回给调用者 int index = binarySearchForIndex(arr,number); System.out.println(index); } private static int binarySearchForIndex(int[] arr, int number) { //1,定义查找的范围 int min = 0; int max = arr.length - 1; //2.循环查找 min <= max while(min <= max){ //3.计算出中间位置 mid int mid = (min + max) >> 1; //mid指向的元素 > number if(arr[mid] > number){ //表示要查找的元素在左边. max = mid -1; }else if(arr[mid] < number){ //mid指向的元素 < number //表示要查找的元素在右边. min = mid + 1; }else{ //mid指向的元素 == number return mid; } } //如果min大于了max就表示元素不存在,返回-1. return -1; } }
注意事项
有一个前提条件，数组内的元素一定要按照大小顺序排列，如果没有大小顺序，是不能使用二分查找法的
冒泡排序
-
冒泡排序概述
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序
如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与
-
代码实现
public class MyBubbleSortDemo2 { public static void main(String[] args) { int[] arr = {3, 5, 2, 1, 4}; //1 2 3 4 5 bubbleSort(arr); } private static void bubbleSort(int[] arr) { //外层循环控制的是次数 比数组的长度少一次. for (int i = 0; i < arr.length -1; i++) { //内存循环就是实际循环比较的 //-1 是为了让数组不要越界 //-i 每一轮结束之后,我们就会少比一个数字. for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } printArr(arr); } private static void printArr(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } }
快速排序
-
快速排序概述
冒泡排序算法中,一次循环结束,就相当于确定了当前的最大值,也能确定最大值在数组中应存入的位置
快速排序算法中,每一次递归时以第一个数为基准数,找到数组中所有比基准数小的.再找到所有比基准数大的.小的全部放左边,大的全部放右边,确定基准数的正确位置
-
核心步骤
- 从右开始找比基准数小的
- 从左开始找比基准数大的
- 交换两个值的位置
- 红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
- 基准数归位
-
代码实现
-
public class MyQuiteSortDemo2 { public static void main(String[] args) { // 1，从右开始找比基准数小的 // 2，从左开始找比基准数大的 // 3，交换两个值的位置 // 4，红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止 // 5，基准数归位 int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8}; quiteSort(arr,0,arr.length-1); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } } private static void quiteSort(int[] arr, int left, int right) { // 递归结束的条件 if(right < left){ return; } int left0 = left; int right0 = right; //计算出基准数 int baseNumber = arr[left0]; while(left != right){ // 1，从右开始找比基准数小的 while(arr[right] >= baseNumber && right > left){ right--; } // 2，从左开始找比基准数大的 while(arr[left] <= baseNumber && right > left){ left++; } // 3，交换两个值的位置 int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp; } //基准数归位 int temp = arr[left]; arr[left] = arr[left0]; arr[left0] = temp; // 递归调用自己,将左半部分排好序 quiteSort(arr,left0,left-1); // 递归调用自己,将右半部分排好序 quiteSort(arr,left +1,right0); } }
Date类
构造方法
| public Date() | 分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒 |
| public Date(long date) | 分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数 |
Date类常用方法
先创建Date对象再调用
| public long getTime() | 获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值 |
| public void setTime(long time) | 设置时间，给的是毫秒值 |
SimpleDateFormat类
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
我们重点学习日期格式化和解析
- 格式化(从Date到String)
- public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析(从String到Date)
- public Date parse(String source)：从给定字符串的开始解析文本以生成日期
SimpleDateFormat类构造方法
-
| public SimpleDateFormat() | 构造一个SimpleDateFormat，使用默认模式和日期格式 |
-
| public SimpleDateFormat(String pattern) | 构造一个SimpleDateFormat使用给定的模式和默认的日期格式 |
LocalDate 类 表示日期（年月日）
LocalTime类 表示时间（时分秒）
LocalDateTime类 表示时间+ 日期 （年月日时分秒）
- | public static LocalDateTime now() | 获取当前系统时间
- | public static LocalDateTime of (年, 月 , 日, 时, 分, 秒) | 使用指定年月日和时分秒初始化一个LocalDateTime对象 |
LocalDateTime类获取方法
| public int getYear() | 获取年 |
|---|---|
| public int getMonthValue() | 获取月份（1-12） |
| public int getDayOfMonth() | 获取月份中的第几天（1-31） |
| public int getDayOfYear() | 获取一年中的第几天（1-366） |
| public DayOfWeek getDayOfWeek() | 获取星期 |
| public int getMinute() | 获取分钟 |
| public int getHour() | 获取小时 |
LocalDateTime转换方法
| public LocalDate toLocalDate () | 转换成为一个LocalDate对象 |
| public LocalTime toLocalTime () | 转换成为一个LocalTime对象 |
public class JDK8DateDemo4 {
public static void main(String[] args) {
LocalDateTime localDateTime = LocalDateTime.of(2020, 12, 12, 8, 10, 12);
//public LocalDate toLocalDate () 转换成为一个LocalDate对象
LocalDate localDate = localDateTime.toLocalDate();
System.out.println(localDate);
//public LocalTime toLocalTime () 转换成为一个LocalTime对象
LocalTime localTime = localDateTime.toLocalTime();
System.out.println(localTime);
}
}
LocalDateTime格式化与解析
1.| public String format (指定格式) |把一个LocalDateTime格式化成为一个字符串|
2.| public LocalDateTime parse (准备解析的字符串, 解析格式) | 把一个日期字符串解析成为一个LocalDateTime对象 |
3.| public static DateTimeFormatter ofPattern(String pattern) | 使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象 | Period|
| public static Period between(开始时间,结束时间) | 计算两个“时间"的间隔 |
|---|---|
| public int getYears() | 获得这段时间的年数 |
| public int getMonths() | 获得此期间的总月数 |
| public int getDays() | 获得此期间的天数 |
| public long toTotalMonths() | 获取此期间的总月数 |
示例
LocalDate localDate1 = LocalDate.of(2020, 1, 1);
LocalDate localDate2 = LocalDate.of(2048, 12, 12);
Period period = Period.between(localDate1, localDate2);
System.out.println(period);//P28Y11M11D
//public int getYears() 获得这段时间的年数
System.out.println(period.getYears());//28
//public int getMonths() 获得此期间的月数
System.out.println(period.getMonths());//11
//public int getDays() 获得此期间的天数
System.out.println(period.getDays());//11
//public long toTotalMonths() 获取此期间的总月数
System.out.println(period.toTotalMonths());//347
Duration
| public static Durationbetween(开始时间,结束时间) | 计算两个“时间"的间隔 |
|---|---|
| public long toSeconds() | 获得此时间间隔的秒 |
| public int toMillis() | 获得此时间间隔的毫秒 |
| public int toNanos() | 获得此时间间隔的纳秒 |
示例
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 1, 1, 13, 14, 15);
LocalDateTime localDateTime2 = LocalDateTime.of(2020, 1, 2, 11, 12, 13);
Duration duration = Duration.between(localDateTime1, localDateTime2);
System.out.println(duration);//PT21H57M58S
//public long toSeconds() 获得此时间间隔的秒
System.out.println(duration.toSeconds());//79078
//public int toMillis() 获得此时间间隔的毫秒
System.out.println(duration.toMillis());//79078000
//public int toNanos() 获得此时间间隔的纳秒
System.out.println(duration.toNanos());//79078000000000
扫一扫
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
