Java学习笔记day14-常用API-数据包装类-二分查找-冒泡排序-递归
Day14
常用API
Math类概述
Math包含执行基本数字运算的方法
Math类常用方法
| 方法名 | 说明 |
|---|---|
| public static int abs(int a) | 返回参数的绝对值 |
| public static double ceil(double a) | 向上取整 |
| public static double floor(double a) | 向下取整 |
| public static int round(float a) | 四舍五入 |
| 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() | 返回值为double的正值[0.0,1.0) |
示例：
package math;
public class MathTest {
public static void main(String[] args) {
//public static int abs(int a) 返回参数的绝对值
int abs = Math.abs(-8);
System.out.println(abs);
//public static double ceil(double a) 向上取整
double ceil = Math.ceil(8.5);
System.out.println(ceil);
//public static double floor(double a) 向下取整
double floor = Math.floor(6.4);
System.out.println(floor);
//public static int round(float a) 四舍五入
int round = Math.round(6.45f);
System.out.println(round);
//public static int max(int a,int b) 返回两个int值中的较大值
int max = Math.max(6,8);
System.out.println(max);
//public static int min(int a,int b) 返回两个int值中的较小值
int min = Math.min(6,8);
System.out.println(min);
//public static double pow(double a,double b) 返回a的b次幂的值
double pow = Math.pow(2,3);
System.out.println(pow);
//public static double random() 返回值为随机的double的正值[0.0,1.0)
double random = Math.random();
System.out.println(random);
}
}
运行结果：
8
9.0
6.0
6
8
6
8.0
0.9508660591551303
System类概述
System不能实例化
System类常用方法
| 方法名 | 说明 |
|---|---|
| public static void exit(int status) | 终止当前运行的Java虚拟机，非零表示异常终止 |
| public static long currentTimeMillis() | 返回当前时间（以毫秒为单位） |
| arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数) | 数组copy |
示例：
package system;
public class SystemTest {
public static void main(String[] args) {
//public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
//System.exit(0);
//public static long currentTimeMillis() 返回当前时间（以毫秒为单位）
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println(end-start); //输出结果为for循环所执行的时间
//arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数) 数组copy
int[] arr1 = {1,2,3,4,5};
int[] arr2 = new int[10];
//把arr1中的数拷贝到arr2中
System.arraycopy(arr1,0,arr2,0,arr1.length);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+" "); //结果为：1 2 3 4 5 0 0 0 0 0
}
System.out.println();
//把arr1中的后3个数拷贝到arr2中的后三个位置
System.arraycopy(arr1,2,arr2,7,3);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+" "); //结果为：1 2 3 4 5 0 0 3 4 5
}
}
}
Object类概述
每个类都可以将Object作为父类。所有类都直接或者间接的继承自该类；
构造方法：public Object()
子类的构造方法默认访问无参构造方法的原因：因为他们的顶级父类只有无参构造方法
打印对象产生地址值的原因：
总结
- Object类是所有类的直接或者间接父类
- 直接打印一个对象就是打印这个对象的toString方法的返回值
- Object类的toString方法得到的是对象的地址值
- 一般会对toString方法进行重写
Object类常用方法
| 方法名 | 说明 |
|---|---|
| public String toString() | 返回对象的字符串表示形式。建议所有子类重写该方法，自动生成 |
| public boolean equals(另一个对象) | 比较对象是否相等。默认比较地址，重写可以比较内容，自动生成 |
示例：
Student类
package object;
public class Student {
private String name;
private int 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;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
}
测试类：
package object;
public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student("拉拉裤",101);
Student s2 = new Student("七宝",8);
Student s3 = new Student("七宝",8);
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
System.out.println(s3.equals(s2));
}
}
扩展：
String s1 = "abc";
StringBuilder sb = new StringBuilder("abc");
//此时调用的是String类名中的equals方法，保证参数也是字符串，否则不会比较属性值而直接返回false
System.out.println(s1.equals(sb)); //false
//StringBuilder类中没有重写equals方法，用的就是Object类中的
System.out.println(sb.equals(s1)); //false
Objects类常用方法
| 方法名 | 说明 |
|---|---|
| public static String toString(对象) | 返回参数中对象的字符串表示形式 |
| public static String toString(对象,默认字符串) | 返回对象的字符串表示形式，若对象为空返回默认字符串内容 |
| public static Boolean isNull(对象) | 判断对象是否为空 |
| public static Boolean nonNull(对象) | 判断对象是否为非空 |
Student s1 = new Student("拉拉裤",101);
s1 = null;
String result1 = Objects.toString(s1, "怎么是空呢");
System.out.println(result1); //怎么是空呢
boolean result = Objects.isNull(s1);
System.out.println(result); //true
BigDecimal类
构造方法
| 方法名 | 说明 |
|---|---|
| BigDecimal(double val) | 参数为double |
| BigDecimal(String val) | 参数为String |
BigDecimal bd1 = new BigDecimal(10.0);
BigDecimal bd2 = new BigDecimal("0.5");
System.out.println(bd1); //10
System.out.println(bd2); //0.5
BigDecimal类的常用方法
作用：可以用来精确计算
| 方法名 | 说明 |
|---|---|
| public BigDecimal add(另一个BigDecimal对象) | 加法 |
| public BigDecimal subtract(另一个BigDecimal对象) | 减法 |
| public BigDecimal multiply(另一个BigDecimal对象) | 乘法 |
| public BigDecimal divide(另一个BigDecimal对象) | 除法 |
| public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式) | 除法 |
示例：
package bigDecimal;
import java.math.BigDecimal;
public class BigDecimalTest {
public static void main(String[] args) {
//若要进行精确运算，要使用字符串构造
BigDecimal bd1 = new BigDecimal("0.3");
BigDecimal bd2 = new BigDecimal("0.2");
BigDecimal add = bd1.add(bd2);
System.out.println("和为："+add);
BigDecimal subtract = bd1.subtract(bd2);
System.out.println("差为："+subtract);
BigDecimal multiply = bd1.multiply(bd2);
System.out.println("积为："+multiply);
BigDecimal divide = bd1.divide(bd2);
System.out.println("商为："+divide);
//参数1：表示参数运算的另一个对象
//参数2：表示小数点后精确到多少位
//参数3：舍入模式
//进一法
//去尾法
//四舍五入法
BigDecimal d = bd2.divide(bd1,2,BigDecimal.ROUND_UP); //进一法
BigDecimal d1 = bd2.divide(bd1,2,BigDecimal.ROUND_FLOOR); //去尾法
BigDecimal d2 = bd2.divide(bd1,2,BigDecimal.ROUND_HALF_UP); //四舍五入
System.out.println("进一法："+d);
System.out.println("去尾法："+d1);
System.out.println("四舍五入："+d2);
}
}
运行结果：
基本数据类型包装类
概述
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用操作之一：用于基本数据类型与字符串之间的转换
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
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 |
package integer;
public class IntegerTest {
public static void main(String[] args) {
Integer i1 = new Integer(10);
Integer i2 = new Integer("10");
System.out.println(i1); //10
System.out.println(i2); //10
Integer i3 = Integer.valueOf(20);
Integer i4 = Integer.valueOf("20");
System.out.println(i3); //20
System.out.println(i4); //20
}
}
Integer自动装箱和自动拆箱
- 装箱：把一个基本数据类型变成对应的包装类；
- 自动：Java底层会帮我们自动调用valueOf方法
- 拆箱：把一个包装类型，变成对应的基本数据类型
例：
Integer i = 100; //自动装箱机制
i += 200; //i = i + 200
//会把i这个对象变成基本数据类型100
//100 + 200 = 300
//把基本数据类型300再次自动装箱变成Integer对象赋值给i
System.out.println(i);//300
Integer的成员方法
- static int parseInt(Stirng s) 将字符串类型的整数变成int类型的整数
示例：
String s1 = "100";
int i1 = 200;
System.out.println(s1+i1); //100200 字符串+任意的数据类型，结果都是一个字符串
int i2 = Integer.parseInt(s1); //可以将字符串类型的整数变成int类型的整数
System.out.println(i2+i1); //300
//int--->String
//方式一:+""
int i3 = 100;
String s2 = i3+"";
System.out.println(s2+100); //100100
//方式二:可以调用String类中valueOf方法
String s3 = String.valueOf(i3);
System.out.println(s3+100); //100100
案例：字符串中数据处理
需求：有一个字符串：“91 27 46 38 50“，把其中的每一个数存到int类型的数组中；
思路：
- 定义一个字符串
- 把字符串中的数字数据存储到一个int类型的数组中
- 遍历数组输出结果
package integer;
public class Anli1 {
public static void main(String[] args) {
String s = "91 27 46 38 50";
//利用split方法对字符串进行切割,将得到的结果存入字符串数组中
String[] strArr = s.split(" ");
//定义整型数组用于存储数据
int[] intArr = new int[strArr.length];
//遍历字符串数组,并将数组中的字符串数据转换为整型存入整型数组
for (int i = 0; i < strArr.length; i++) {
intArr[i] = Integer.parseInt(strArr[i]);
}
//遍历整型数组并打印结果
for (int i = 0; i < intArr.length; i++) {
System.out.print(intArr[i]+" ");
}
}
}
运行结果：
数组的高级操作
二分查找
步骤：
- 定义两个变量，表示要查找的范围。默认min=0，max=最大索引
- 循环查找，但是min<=max
- 计算出mid的值
- 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
- 如果要查找的值在mid的左半边，那么min值不变，max=mid-1继续下次循环查找
- 如果要查找的值在mid的右半边，那么max值不变，min=mid+1继续下次循环查找
- 当min>max时，表示要查找的元素在数组中不存在，返回-1
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int num = 4;
int index = binarySearchForIndex(arr,num);
System.out.println(index); //输出结果为3
}
private static int binarySearchForIndex(int[] arr, int num) {
//定义查找的范围
int min = 0;
int max = arr.length-1;
//循环查找
while (min <= max){
//计算出中间位置mid
int mid = (max + min) >> 1; //右移1位，相当于除以2
//判断mid所指的值与num的值的大小
if(arr[mid]>num){
//若mid位置的数大于要查的数，表明目标数在左边
max = mid - 1;
}else if(arr[mid]<num){
//若mid位置的数小于要查的数，表明目标数在右边
min = mid + 1;
}else if(arr[mid]==num){
return mid;
}
}
//如果min>max,表明要查找的值不存在返回-1
return -1;
}
}
冒泡排序
相邻的数据两两比较，小的放前面，大的放后面。
例如将数列：3 5 2 1 4按照从小到大的顺序排列，步骤如下：
- 相邻的元素两两比较，大的放右边，小的放左边，找到最大值；
- 第一次循环结束，最大值已经找到，在数组的最右边；
- 下一次只要在剩余的元素找最大值就可以了；
- 因为已经确定了5是最大值，所以4跟5无须再进行比较了；
- 因为已经确定了5是最大值，4是次大值。所以3无须跟4和5进行比较了；
- 同理3,4,5的位置已经确定了，2也无须与这三个值进行比较了；
- 最后只剩下一个值1了，肯定就放在最后一个格子中。
- 如果有n个数据进行排序，总共需要比较n-1次
- 每一次比较完毕，下一次的比较会少一个数据参与
public class MyBubbleSort {
public static void main(String[] args) {
int[] arr = {3,5,2,1,4};
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();
}
}
运行结果:1 2 3 4 5
递归
-
以编程的角度来看，递归指的是方法定义中调用方法本身的现象。
-
递归解决问题的思路：
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算。
-
递归解决问题要找到两个内容：
- 递归出口：否则会出现内存溢出
- 递归规则：与原问题相似的规模较小的问题
案例：递归求阶乘
需求：用递归求5的阶乘，并把结果在控制台输出
public class Recursion {
public static void main(String[] args) {
int result = getJc(5);
System.out.println(result);
}
private static int getJc(int i) {
//当i=1时递归结束
if(i==1){
return 1;
}else{
//递归规则,方法再一次被调用时，参数值会更接近出口
return i*getJc(i-1);
}
}
}
运行结果:120
递归执行步骤分析
快速排序
- 冒泡排序算法中，一次循环结束，就相当于确定了当前的最大值，也能确定最大值在数组中应存入的位置。
- 快速排序算法中，每一次递归时以第一个数为基准数，找到数组中所有比基准数小的，再找到所有比基准数大的。小的全部放左边，大的全部放右边，确定基准数的正确位置。
快速排序步骤：
- 从右开始找比基准数小的
- 从左开始找比基准数大的
- 交换两个值的位置
- 右边的继续往左找，左边的继续往右找，直到两边指向同一个索引为止
- 基准数归位
示例：
public class MyQuikSort {
public static void main(String[] args) {
int[] arr = {6,1,2,7,9,3,4,10,8,5};
quikSort(arr,0,arr.length-1); //参数为数组以及数组两端的索引
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
private static void quikSort(int[] arr, int left, int right) {
if(right<=left){
return;
}
int l = left;
int r = right;
//计算出基准数
int baseNumber = arr[l];
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[l];
arr[l] = temp;
quikSort(arr,l,left-1);
quikSort(arr,left+1,r);
}
}
运行结果：1 2 3 4 5 6 7 8 9 10
Arrays
- public static String toString(int[] a) 返回指定数组的内容的的字符串表示形式
- public static void sort (int[] a) 按照数字顺序排列指定的数组
- public static int binarySearch(int[] a,int key) 利用二分查找返回指定元素的索引
示例：
import java.util.Arrays;
public class ArraysTest {
public static void main(String[] args) {
int[] arr = {2,4,5,1,6,7,3,8};
//返回指定数组的内容的的字符串表示形式
String s = Arrays.toString(arr);
System.out.println(s);
//按照数字顺序排列指定的数组
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//利用二分查找返回指定元素的索引
int index = Arrays.binarySearch(arr,5);
System.out.println(index);
int index1 = Arrays.binarySearch(arr,10);
System.out.println(index1);
//数组必须有序
//如果要查找的元素存在，那么返回的是这个元素的实际索引
//如果要查找的元素不存在，那么返回的是(-插入点-1)
//插入点:如果这个元素在数组中，他应该在哪个索引上，
// 例如：10在数组中应该在8的后面，即索引8上，则查找10返回的结果为-8-1=-9
}
}
运行结果：
练习1
请编程进行以下运算：计算3的5次幂；计算3.3向上取整的结果；计算3.9向下取整的结果；计算6.7四舍五入取整的结果
/*
请计算3的5次幂
请计算3.3向上取整的结果
请计算3.9向下取整的结果
请计算6.7四舍五入取整的结果
*/
public class Lian1 {
public static void main(String[] args) {
//3的5次幂
double a = Math.pow(3,5);
System.out.println("3^5="+a);
//3.2向上取整
double b = Math.ceil(3.3);
System.out.println("3.2向下取整为："+b);
//3.8向下取整
double c = Math.floor(3.9);
System.out.println("3.8向下取整为："+c);
//5.6四舍五入
int d = Math.round(6.7f);
System.out.println("6.7四舍五入为："+d);
}
}
运行结果：
练习2
定义一个集合，并将1至1千万这1千万个数字添加到集合中，计算这个行为运行的时间；
import java.util.ArrayList;
public class Lian2 {
public static void main(String[] args) {
//创建一个集合
ArrayList list = new ArrayList();
//记录当前开始时间
Long start = System.currentTimeMillis();
//循环向集合中添加1千万个数字
for (int i = 1; i <= 10000000; i++) {
list.add(i);
}
//记录添加结束时间
Long end = System.currentTimeMillis();
//求开始和结束时间差，即可的添加用时
Long time = end - start;
System.out.println("向集合中添加一千万个数字用的时间是："+time+"毫秒");
}
}
运行结果：
练习3
求以下double数组的平均值(四舍五入保留两位小数)：double[] arr = {0.1,0.2,2.1,3.2,5.56,7.21};
import java.math.BigDecimal;
public class Lian3 {
public static void main(String[] args) {
double[] arr = {0.1,0.2,2.1,3.2,5.56,7.21};
//若要进行精确运算，要使用字符串构造
BigDecimal sum = new BigDecimal("0");
for (int i = 0; i < arr.length; i++) {
//将数组中的数转化成字符串，然后在循环求和
BigDecimal bd1 = new BigDecimal(arr[i]+"");
sum = sum.add(bd1);
}
//System.out.println(sum);
BigDecimal l = new BigDecimal(arr.length+"");
//四舍五入保留两位小数
BigDecimal divide = sum.divide(l,2,BigDecimal.ROUND_HALF_UP);
System.out.println("数组的平均值是："+divide);
}
}
运行结果：
练习4
在一行中通过键盘输入自己的年龄和身高(要带小数)，年龄和身高中间使用逗号分隔，请利用今天的技术和字符串的切分方法，将键盘输入的数据转成整数和小数；
import java.util.Scanner;
public class Lian4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄和身高：(年龄是整数，身高是小数，中间使用逗号分隔)");
String ah = sc.next();
String[] arr = ah.split(",");
int age = Integer.parseInt(arr[0]);
double height = Double.parseDouble(arr[1]);
System.out.println("转成整数后的年龄是："+age);
System.out.println("转成小数后的身高是："+height);
}
}
运行结果：
练习5
已知数组如下：
int[] arr = {429,55,25,25,27,41,2,5,66,3,64,6,45,8,51};1.使用Arrays对数组元素进行排序并打印排序后的结果；2.使用二分法查找元素2，并打印查询结果；3.使用二分法查找200，并打印查找结果；
import java.util.Arrays;
public class Lian5 {
public static void main(String[] args) {
int[] arr = {429,55,25,25,27,41,2,5,66,3,64,6,45,8,51};
Arrays.sort(arr);
String s = Arrays.toString(arr);
System.out.println(s);
int index1 = Arrays.binarySearch(arr,2);
System.out.println("元素2在数组中的索引是："+index1);
int index2 = Arrays.binarySearch(arr,200);
System.out.println("元素200在数组中的索引是："+index2);
}
}
运行结果：
练习6
使用递归计算从1到100之间的所有数之和。
public class Lian6 {
public static void main(String[] args) {
int i = 1;
int sum = sum(i);
System.out.println(sum); //5050
}
public static int sum(int i){
//i=100时递归结束
if(i==100){
return 100;
}else{
return i+sum(i+1);
}
}
}