1、API
1.1、API概述
什么是API
API(Application Programming Interface):应用程序编程接口 Java中的API
指的是JDK中提供的各种功能的java类,这些类将底层的实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可,我们通过帮助文档来学习这些API如何使用
1.2、如何使用API帮助文档
打开帮助文档 找到索引选项卡中的输入框 在输入框中输入Random 看在哪个包下 看类的描述 看构造方法 看成员方法
2、常用API
2.1、Math
Math类概述
Math类方法的调用方式
Math类中无构造方法,但内部的方法都是静态的,则可以通过 类名.进行调用 Math类的常用方法
方法名 说明 public static int abs(int a) 返回参数的绝对值 public static double ceil(double a) 返回大于或等于参数的最小double值,等于一个整数 public static double floor(double a) 返回小于或等于参数的最大double值,等于一个整数 public static int round(float a) 按照四舍五入返回最接近参数的int值 public static int max(int a,int b) 返回两个int值中的较大值 public static int min(int a,int b) 返回两个int值中的较小值 public static double pow(double a,double b) 返回a的b次幂的值 public static double random() 返回值为dobule的正值,[0.0,1.0)
2.2、System
方法名 说明 public static void exit(int status) 终止当前运行的java虚拟机,非零表示异常终止 public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
示例代码
需求:在控制台输出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) + "毫秒" ) ;
}
}
2.3、Object类的toString方法
Object类概述
Object是类层次结构的根,每个类都可以将Object类作为超类。所有类都直接或间接的继承自该类,换句话说,该类所具备的方法,所有类都会有一份 查看源码的方式
重写toString方法的方式
Alt + insert选中toString 在类的空白区域,右键->Generate->选择toString toString方法的作用
示例代码
public class Student extends Object {
private String name;
private int age;
public Student ( ) {
}
public Student ( String name, int age) {
this . name = name;
this . age = age;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public int getAge ( ) {
return age;
}
public void setAge ( int age) {
this . age = age;
}
@Override
public String toString ( ) {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}' ;
}
}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
public class ObjectDemo {
public static void main ( String [ ] args) {
Student s = new Student ( ) ;
s. setName ( "林青霞" ) ;
s. setAge ( 30 ) ;
System . out. println ( s) ;
System . out. println ( s. toString ( ) ) ;
}
}
== == == == == == == == == == == == == == == == == == == == == == == == == == ==
Student { name= '林青霞' , age= 30 }
Student { name= '林青霞' , age= 30 }
进程已结束,退出代码 0
== == == == == == == == == == == == == == == == == == == == == == == == == == =
2.4、Object类的equals方法
equals方法的作用
用于对象之间的比较,返回true和false的结果 举例:s1.equals(s2); s1和s2是两个对象 重写equals方法的场景
不希望比较对象的地址值,想要结合对象属性进行比较的时候 重写equals方法的方式
alt + insert 选择equals() and hashCode(), IntelliJ Default,一路next,finsh即可 在类的空白区域,右键→Generate→选择equals() and hashCode(),后面的同上 示例代码
public class Student extends Object {
private String name;
private int age;
@Override
public boolean equals ( Object o) {
if ( this == o) return true ;
if ( o == null || getClass ( ) != o. getClass ( ) ) return false ;
Student student = ( Student ) o;
return age == student. age &&
Objects . equals ( name, student. name) ;
}
@Override
public int hashCode ( ) {
return Objects . hash ( name, age) ;
}
public Student ( ) {
}
public Student ( String name, int age) {
this . name = name;
this . age = age;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public int getAge ( ) {
return age;
}
public void setAge ( int age) {
this . age = age;
}
@Override
public String toString ( ) {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}' ;
}
}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
public class ObjectDemo {
public static void main ( String [ ] args) {
Student s = new Student ( ) ;
s. setName ( "林青霞" ) ;
s. setAge ( 30 ) ;
Student s2 = new Student ( ) ;
s2. setName ( "林青霞" ) ;
s2. setAge ( 30 ) ;
System . out. println ( s. equals ( s2) ) ;
}
}
//看程序,分析结果
String s = "abc";
StringBuilder sb = new StringBuilder("abc");
s.equals(sb);
sb.equals(s);
public class InterviewTest {
public static void main ( String [ ] args) {
String s1 = "abc" ;
StringBuilder sb = new StringBuilder ( "abc" ) ;
System . out. println ( s1. equals ( sb) ) ;
System . out. println ( sb. equals ( s1) ) ;
}
}
2.5、Objects
方法名 说明 public static String toString(对象) 返回参数中对象的字符串表示形式 public static String toString(对象,默认字符串) 返回对象的字符串表示形式 public static Boolean isNull(对象) 判断对象是否为空 public static Boolean nonNull(对象) 判断对象是否不为空
public class Student extends Object {
private String name;
private int age;
public Student ( ) {
}
public Student ( String name, int age) {
this . name = name;
this . age = age;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public int getAge ( ) {
return age;
}
public void setAge ( int age) {
this . age = age;
}
@Override
public String toString ( ) {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}' ;
}
}
测试类
public class MyObjectsDemo {
public static void main ( String [ ] args) {
Student s = null ;
boolean result = Objects . nonNull ( s) ;
System . out. println ( result) ;
}
}
2.6、BigDecimal
方法名 说明 BigDecimal(double val) 参数为double BigDecimal(String val) 参数为String
方法名 说明 public BigDecimal add(另一个BigDecimal对象) 加法 public BigDecimal subtract(另一个BigDeciaml对象) 减法 public BigDecimal multiply(另一个BigDeciaml对象) 乘法 public BigDecimal divide(另一个BigDeciaml对象) 除法 public BigDecimal divide(另一个BigDeciaml对象,精确几位,舍入模式) 除法
总结
BigDecimal是用来进行精确计算的 创建BigDecimal的对象,构造方法使用参数类型为字符串的 四则运算中的除法,如果除不尽请使用divide的三个参数的方法 代码示例
BigDecimal divide = bd1.divide(参与运算的对象,小数点后精确到多少位,摄入模式);
参数1,表示参与运算的BigDecimal对象
参数2,表示小数点后面精确到多少位
参数3,舍入模式
BigDecimal.ROUND_UP 进一法
BigDecimal.ROUND_FLOOR 去尾法
BigDecimal.ROUND_HALF_UP 四舍五入
3、包装类
3.1、基本类型包装类
基本类型包装类的作用
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 常用的操作之一:用于基本数据类型与字符串之间的转换 基本类型对应的包装类
基本数据类型 包装类 byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean
3.2、Integer类
方法名 说明 public Integer(int value) 根据int值创建Integer对象(过时) public Integer(String s) 根据String值创建Integer对象(过时) public static Integer valueOf(int i) 返回表示指定的int值Integer实例 public static Integer valueOf(String s) 返回一个保存指定值的Integer对象String
public class IntegerDemo {
public static void main ( String [ ] args) {
Integer i1 = new Integer ( 10 ) ;
System . out. println ( i1) ;
Integer i2 = new Integer ( "100" ) ;
System . out. println ( i2) ;
System . out. println ( "-------------" ) ;
Integer i3 = Integer . valueOf ( 100 ) ;
System . out. println ( i3) ;
Integer i4 = Integer . valueOf ( "100" ) ;
System . out. println ( i4) ;
}
}
3.3、自动拆箱和自动装箱
Integer i = 100 ;
i += 200 ;
3.4、int和string类型的相互转换
int转换为String
转换方式:
方式一:直接在数字后面加一个空字符串 方式二:通过String类静态方法valueOf() 示例代码
public class IntegerDemo01 {
public static void main ( String [ ] args) {
int num = 100 ;
String s1 = num + "" ;
System . out. println ( s1) ;
String s2 = String . valueOf ( num) ;
System . out. println ( s2) ;
}
}
String转换为int
转换方式
方式一:先将字符串数字转成Integer,再调用valueOf()方法 方式二:通过Integer静态方法parseInt()进行转换 示例代码
public class IntegerDemo02 {
public static void main ( String [ ] args) {
String s = "100" ;
Integer i = Integer . valueOf ( s) ;
int x = i. intValue ( ) ;
System . out. println ( x) ;
int y = Integer . parseInt ( s) ;
System . out. println ( y) ;
}
}
3.5、字符串数据排序案例
案例需求:
有一个字符串:“91 27 46 38 50”,请写程序试下最终输出结果为:27 38 46 50 91 代码实现
import java. util. Arrays ;
public class IntegerTest {
public static void main ( String [ ] args) {
String s = "91 27 46 38 50" ;
String [ ] strArray = s. split ( " " ) ;
int [ ] arr = new int [ strArray. length] ;
for ( int i = 0 ; i < arr. length; i++ ) {
arr[ i] = Integer . parseInt ( strArray[ i] ) ;
}
Arrays . sort ( arr) ;
for ( int i = 0 ; i < arr. length; i++ ) {
System . out. print ( arr[ i] + " " ) ;
}
}
}
== == == == == == == == == == == == == == == == == == == == == == == == ==
27 38 46 50 91
进程已结束,退出代码 0
== == == == == == == == == == == == == == == == == == == == == == == == ==
4、递归
4.1、递归
递归的介绍
以编程的角度来看,递归指的是方法定义中调用方法本身的现象 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解 递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算 递归的基本使用
public class MyFactorialDemo {
public static void main ( String [ ] args) {
int sum = getSum ( 100 ) ;
System . out. println ( sum) ;
}
private static int getSum ( int i) {
if ( i == 1 ) {
return 1 ;
} else {
return i + getSum ( i - 1 ) ;
}
}
}
递归的注意事项
递归一定要有出口,否则内存溢出 递归虽然有出口,但是递归的次数不宜过多,否则内存溢出
4.2、递归求阶乘
public class DiGuiDemo {
public static void main ( String [ ] args) {
int result = jc ( 5 ) ;
System . out. println ( "5的阶乘:" + result) ;
}
private static int jc ( int n) {
if ( n == 1 ) {
return 1 ;
} else {
return n* jc ( n- 1 ) ;
}
}
}
内存图
5、数组的高级操作
二分查找概述
查找指定元素在数组中的位置时,以前的方式是通过遍历,逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时 ,查找的效率很低 二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率 需求:
在数组{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 MyBianrySearchDemo {
public static void main ( String [ ] args) {
int [ ] arr = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
int num = 11 ;
int index = binarySearchForIndex ( arr, num) ;
System . out. println ( index) ;
}
private static int binarySearchForIndex ( int [ ] arr, int num) {
int min = 0 ;
int max = arr. length - 1 ;
while ( min <= max ) {
int mid = ( min + max) >> 1 ;
if ( arr[ mid] > num) {
max = mid + 1 ;
} else if ( arr[ mid] < num) {
min = mid + 1 ;
} else {
return mid;
}
}
return - 1 ;
}
}
注意事项
有一个前提条件,数组内的元素一定要按照大小顺序排列,如果没有大小排序,是不能使用二分查找的
5.2、冒泡排序
冒泡排序概述
一种排序的方式,对要进行排序的数据中相邻的数据进行两两比较,将较大的数据放在后面,依次对所有的数据进行操作,直至所有的数据按有求完成排序 如果有n个数据进行排序,总共需要比较n-1次 每一次比较完毕,下一次的比较就会少一个数据参与 代码实现
public class MyBubbleSortDemo {
public static void main ( String [ ] args) {
int [ ] arr = { 3 , 5 , 2 , 1 , 4 } ;
bubbeSort ( arr) ;
}
private static void bubbeSort ( int [ ] arr) {
for ( int i = 0 ; i < arr. length - 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 ( ) ;
}
}
5.3、快速排序
快速排序概述
冒泡排序算法中,一次循环结束,就相当于确定了当前的最大值,也能确定最大值在数组中应存入的位置,快速排序算法中,每一次递归时以第一个数为基准,找到数组中所有比基准数小的,再找到所有比基准数大的,小的全部放左边,大的全部放右边,确定基准数的正确位置 核心步骤
从右开始找比基准数小的 从左开始找比基准数大的 交换两个值的位置 红色继续往左找,蓝色继续往右找,直到两个箭头指向同一个索引为止 基准数归位 代码实现
public class MyQuiteSortDemo {
public static void main ( String [ ] args) {
int [ ] arr = { 6 , 1 , 2 , 7 , 9 , 3 , 4 , 5 , 10 , 8 } ;
quiteSort ( arr, 0 , arr. length- 1 ) ;
}
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) {
while ( arr[ right] >= baseNumber && right> left) {
right-- ;
}
while ( arr[ left] <= baseNumber && right > left) {
left++ ;
}
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) ;
}
}
5.4、Arrays
方法名 说明 public static String toString(int[] a) 返回指定数组的内容的字符串表示形式 public static void sort(int[] a) 按照数字顺序排列指定的数组 public static int binarySearch(int[] a,int key) 利用二分查找返回指定元素的索引
public class MyArraysDemo {
public static void main ( String [ ] args) {
int [ ] arr = { 3 , 2 , 4 , 6 , 7 } ;
System . out. println ( Arrays . toString ( arr) ) ;
int [ ] arr = { 3 , 2 , 4 , 6 , 7 } ;
Arrays . sort ( arr) ;
System . out. println ( Arrays . toString ( arr) ) ;
int [ ] arr = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
int index = Arrays . binarySearch ( arr, 0 ) ;
System . out. println ( index) ;
}
}
工具类设计思想
构造方法用private修饰 成员用public static 修饰