1 API的基本使用
API: 应用程序接口,学习API就是学习JDK中给我们提供的类.
这些类在学习的时候需要去查看API文档进行学习,API就是JDK官方针对这些类提供的说明书.
学习某一个类的思路:
- 查看这个类所在的包,如果是java.lang包在使用的时候不需要进行导包操作
- 看这个类所对应的继承关系
- 查看这个类的描述(了解)
- 查看这个类开始的JDK版本
- 查看这个类的构造方法 ----->目的: 查看这个类应该如何创建对象
- 查看这个类的成员方法
2 Math类
Math类所在包就是java.lang,在使用的时候不需要导包.Math提供了一些常见的数学运算的方法,获取两个数据的最大值,获取a的b次幂…
在Math类中没有提供公共的构造方法,但是它里面的所有成员方法都是静态的,可以直接通过类名进行访问
代码示例:
public class MathDemo {
public static void main(String[] args) {
//public static int abs(int a) 返回参数的绝对值
int abs = Math.abs(10);
System.out.println(abs);
//public static double ceil(double b) 向上取整
double ceil = Math.ceil(10.1);
System.out.println(ceil);
//public static double floor(double a) 向下取整
double floor = Math.floor(10.9);
System.out.println(floor);
//public static int round(float a) 四舍五入
long round = Math.round(10.2);
System.out.println(round);
long round1 = Math.round(1.6);
System.out.println(round1);
//public static int max(int a, int b) 返回两个int值中的较大值
int max = Math.max(20,10);
System.out.println(max);
//public static int min(int a, int b) 返回两个int值中的较小值
int min =Math.min(30,50);
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]
for (int i = 0; i < 10; i++) {
double random = Math.random();
System.out.println(random);
}
}
}
3 System类
System类所在的包就是java.lang ，在使用的时候不需要进行导包操作。System类主要提供了一些和系统操作相关的方法。
System类中没有公共的构造方法,在System类中所提供的方法大部分都是静态的，可以直接通过类名进行访问。
public static void exit(int status) // 退出java虚拟机,参数往往传递的都是0
public static long currentTimeMillis() // 获取当前系统时间对应的毫秒值
public static long nanoTime() // 获取当前系统时间的纳秒值
/*
src:表示的源数组
srcPos：源数组对应的元素的起始索引
dest：表示的目标数组
destPos：目标数组的索引
length：个数
*/
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) // 进行数组元素的copy
示例代码:
public class SystemDemo {
public static void main(String[] args) {
// public static void exit(int status) 终止当前运行的 Java 虚拟机，非零表示异常终止
// System.out.println(111);
// //while(true){}
// System.exit(0); //当代码执行到这个方法的时候,就表示虚拟机已经停止了
// System.out.println(2222);
// public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
// long start = System.currentTimeMillis();//获取当前时间
// //System.out.println(l);
// for (int i = 0; i < 10000; i++) {
// System.out.println(i);
// }
// long end = System.currentTimeMillis();//获取当前时间
// System.out.println(end - start);//472 --- 得到的就是这个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.println(arr2[i]);
}*/
//我要把arr1最后两个元素,拷贝到arr2的最后两个索引上
System.arraycopy(arr1,3,arr2,8,2);
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
// 获取当前系统时间的纳秒值
long nanoTime = System.nanoTime();
System.out.println(nanoTime);
}
}
4 Object类
4.1 toString方法
Object是整个继承体系的根类,所有的类都是直接或者简介继承该类.因此我们之前所定义的类是可以去使用Object类中所定义的方法
public String toString() // 返回对象的字符串表现形成，默认情况下是由两部分组成：包名 + 类名@int类的值
直接输出某一个引用变量的时候，默认会调用Object类中的toString方法
public class Demo {
public static void main(String[] args) {
Student s = new Student("张三",23);
System.out.println(s.toString());//com.itheima.demo1.Student@3f3afe78
System.out.println(s); // 默认情况下会调用toString方法
}
}
toString方法在Object类中默认返回值就是对象的地址值,但是一般情况下我们把对象的地址值打印到控制台没有太大的意义,因此我们常常需要对Object类中的toString方法进行重写,重写的时候返回的就是对象的成员变量的字符串拼接形式,使用idea的快捷键(alt + insert)完成
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
4.2 equals方法
在Object类中的equals方法默认比较的是地址值(指示某个其他对象是否“等于”此对象).源码:
public boolean equals(Object obj) {
return (this == obj);
}
如果我们需要比较两个对象的内容，就需要去重写Object类中的equals方法，重写可以直接使用idea中快捷键（alt + insert）进行生成。
@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;
}
4.3 面试题
public class InterviewTest {
public static void main(String[] args) {
String s1 = "abc";
StringBuilder sb = new StringBuilder("abc");
//1.此时调用的是String类中的equals方法.
//保证参数也是字符串,否则不会比较属性值而直接返回false
//System.out.println(s1.equals(sb));
//StringBuilder类中是没有重写equals方法,用的就是Object类中的.
System.out.println(sb.equals(s1));
}
}
5 Objects类
Objects类所在的包就是java.util这个包,那么在使用的时候就需要导包.作用: 提供了很多对象操作的方法,可以认为就是对象的工具类.
Objects类中没有公共的构造方法,它里面的成员方法大部分都是静态的,可以直接通过类名来调用.
代码实现:
public class MyObjectsDemo {
public static void main(String[] args) {
// public static String toString(对象): 返回参数中对象的字符串表示形式。
// Student s = new Student("小罗同学",50);
// String result = Objects.toString(s);
// System.out.println(result);
// System.out.println(s);
// public static String toString(对象, 默认字符串): 返回对象的字符串表示形式。如果对象为空,那么返回第二个参数.
//Student s = new Student("小花同学",23);
// Student s = null;
// String result = Objects.toString(s, "随便写一个");
// System.out.println(result);
// public static Boolean isNull(对象): 判断对象是否为空
//Student s = null;
// Student s = new Student();
// boolean result = Objects.isNull(s);
// System.out.println(result);
// public static Boolean nonNull(对象): 判断对象是否不为空
//Student s = new Student();
Student s = null;
boolean result = Objects.nonNull(s);
System.out.println(result);
}
}
6 BigDecimal类
BigDecimal类这个类是在java.math这个包中，使用的时候需要进行导包。作用：使用BigDecimal可以进行浮点数的数学运算符，它可以保证的数据精度更加准确点,常常会在金融项目中进行使用。
构造方法:
public BigDecimal(String val) // 把一个数字字符串转换成BigDecimal的对象
使用这个构造方法创建出来的BigDecimal对象,后期在进行数据运算的时候不会存在精度丢失的问题
成员方法:
示例代码:
public class MyBigDecimalDemo3 {
//如果想要进行精确运算,那么请使用字符串的构造
public static void main(String[] args) {
// BigDecimal bd1 = new BigDecimal(0.1);
// BigDecimal bd2 = new BigDecimal(0.2);
BigDecimal bd1 = new BigDecimal("0.1");
BigDecimal bd2 = new BigDecimal("0.2");
// public BigDecimal add(另一个BigDecimal对象) 加法
BigDecimal add = bd1.add(bd2);
System.out.println("和为" + add);
//System.out.println(0.1 + 0.2);
// public BigDecimal subtract (另一个BigDecimal对象) 减法
BigDecimal subtract = bd1.subtract(bd2);
System.out.println("差为" + subtract);
// public BigDecimal multiply (另一个BigDecimal对象) 乘法
BigDecimal multiply = bd1.multiply(bd2);
System.out.println("积为" + multiply);
// public BigDecimal divide (另一个BigDecimal对象) 除法
BigDecimal divide = bd1.divide(bd2);
System.out.println("商为"+divide);
}
}
BigDecimal divide = bd1.divide(参与运算的对象,小数点后精确到多少位,舍入模式);
参数1 ，表示参与运算的BigDecimal 对象。
参数2 ，表示小数点后面精确到多少位
参数3 ，舍入模式
BigDecimal.ROUND_UP 进一法
BigDecimal.ROUND_FLOOR 去尾法
BigDecimal.ROUND_HALF_UP 四舍五入
7 基本数据类型包装法
7.1概述
概述:就是jdk针对基本数据类型所提供的引用数据类型。
为什么JDK中需要针对基本数据类型提供对应的引用数据类型？
原因:
- 为了不打脸 ----> 面向对象语言，面向对象的语言强调的是对象，在高司令的思想中，万物皆对象。
- 是引用数据类型就可以定义很多的方法，通过方法可以方便的操作这些数据
每一种基本数据类型所对应的引用数据类型
这些包装类类型在使用的时候功能都很类似，因此本次我们就以Integer举例给大家演示一下如何使用包装类类型。
7.2 Integer对象的获取
- 使用构造方法进行获取
public Integer(int value) // 根据int类型的值创建一个Integer对象
public Integer(String s) // 根据一个数字字符串创建一个Integer对象
- 使用valueOf进行获取
public static Integer valueOf(int i) // 根据int类型的值创建一个Integer对象
public static Integer valueOf(String s) // 根据一个数字字符串创建一个Integer对象
示例代码:
public class MyIntegerDemo2 {
public static void main(String[] args) {
// public Integer(int value) 根据int创建Integer对象(过时)
//public Integer(String s) 根据String值创建Integer对象(过时)
Integer i1 = new Integer(100);
Integer i2 = new Integer("100");
System.out.println(i1);
System.out.println(i2);
// public static Integer valueOf(int i) 返回表示指定的int值的Integer实例
// public static Integer valueOf(String s) 返回一个保存指定值的Integer对象String
Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf("200");
System.out.println(i3);
System.out.println(i4);
}
}
7.3 自动拆装箱
在jdk1.5以后提供了一个新特性自动拆装箱
自动装箱:把基本数据类型自动转换成引用数据类型
Integer i1 = 100;
自动拆箱: 把引用数据类型自动转换成基本数据类型
Integer i1 = 100;
int i2 = i1 ;
自动拆装箱的示例代码:
Integer i3 = 100; //自动装箱机制
i3 += 200; // i3 = i3 + 200;
// 先进行自动拆箱 ， 在进行自动装箱
System.out.println(i3);
细节问题:
Integer i4 = null ;
if(i4 != null) { // 在进行操作之前首先需要进行判断
i4 += 100 ; // i4 = i4 + 100 ;
// 首先需要对i4进行拆箱的操作，那么在进行拆箱的时候肯定需要调用对应的方法进行实现，而i4现在的值是null
// 使用null调用方法肯定NullPointerException
System.out.println(i4);
}
7.4常见的用途
常见的用途就是用来完成字符串和基本数据类型之间的转换
基本数据类型的数据转换成字符
int转换String
- 直接给int类型的数据加上一个空字符串
int a = 123 ;
String strNumber = a + "" ;
- 借助于String类中的静态方法valueOf方法进行实现
int a = 123 ;
String value = String.valueOf(a);
把字符串转换成基本数据类型的数据
String转换成int
- 把String转换成Integer，然后在调用Integer类中的方法获取int类型的数据
String s = "123" ;
// 转换成Integer类型
Integer integer = Integer.valueOf(s);
// 从Integer中获取int类型的数据： public int intValue()
int value = integer.intValue();
System.out.println(value);
- 直接调用Integer类中的parseInt方法进行转换（重点）
String s = "123" ;
int parseInt = Integer.parseInt(s);
System.out.println(parseInt);
7.5 练习
案例需求：有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：27 38 46 50 91
步骤:
-
定义一个字符串（“91 27 46 38 50”）
-
对字符串进行切割（使用空格进行切割），切割完毕以后得到是一个字符串数组
-
把字符串数组转换成int类型的数组
定义一个int类型的数组，数组的长度就是字符串数组长度
遍历字符串数组，获取每一个元素，然后将其转换成int类型的数据
将这个int类型的数据存储到int类型的数组中 -
对int类型的数组进行排序（从小到大进行排序）
使用Arrays中的sort方法进行排序
public static void sort(int[] a)
- 输出int类型数组中的数据
代码实现:
public class MyIntegerDemo08 {
public static void main(String[] args) {
// 定义一个字符串（“91 27 46 38 50”）
String s = "91 27 46 38 50" ;
// 对字符串进行切割（使用空格进行切割），切割完毕以后得到是一个字符串数组
String[] split = s.split(" ");
// 把字符串数组转换成int类型的数组
int[] arr = new int[split.length] ;
// 遍历字符串数组
for(int x = 0 ; x < split.length ; x++) {
// 获取每一个元素，然后将其转换成int类型的数据
int number = Integer.parseInt(split[x]) ;
// 将这个int类型的数据存储到int类型的数组中
arr[x] = number ;
}
// 对int类型的数组进行排序（从小到大进行排序）
Arrays.sort(arr);
// 输出int类型数组中的数据
for(int x = 0 ; x < arr.length; x++) {
System.out.print(arr[x] + " ");
}
}
}
8 数组的高级操作
8.1 二分查找
前提: 要求元素必须有序
原理: 每一个在查询的时候都是使用数组中中间索引所对应的元素和要查找的元素进行比对。
比对就存在3中情况:
- 中间索引处的元素和要查找的元素相同，说明找到了，直接返回中间索引
- 要查找的元素大于中间索引所对应的元素，以中间所以为划分点从右侧进行查找
- 要查找的元素小于中间索引所对应的元素，以中间所以为划分点从左侧进行查找
在进行第二次查询的时候也是使用中间索引所对应的元素和要查找的元素进行比对。
8.2 代码实现
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;
}
}
8.3 冒泡排序
冒泡排序的原理
原理:相邻的两个元素进行比较，大的往后放，小的往前放。
进行第一次排序以后,元素的最大值就已经确定了,在最后一个索引处
代码实现:
public class MyBubbleSortDemo {
public static void main(String[] args) {
int[] arr = {3, 5, 2, 1, 4};
//1 2 3 4 5
//第一轮
//把最大值5找出,并把它放到数组的最右边
//-1 是为了让索引不超出范围
for (int i = 0; i < arr.length - 1 - 0; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
printArr(arr);
//第二轮
for (int i = 0; i < arr.length - 1 - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
printArr(arr);
//第三轮
for (int i = 0; i < arr.length - 1 - 2; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
printArr(arr);
//第四轮
for (int i = 0; i < arr.length - 1 -3; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 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();
}
}
8.4 递归
递归的概述
递归:方法定义中调用方法本身的现象
public static void show() {
show() ;
}
注意事项：递归一定要存在出口，如果不存在出口就会产生内存溢出
计算1-100之间的数据和
private static int getSum(int i) { //作用：计算1-i之间的数据和
//1- 100之间的和
//100 + (1-99之间的和)
// 99 + (1- 98之间的和)
//....
//1
//方法的作用: 求 1- i 之间和
if(i == 1){
return 1;
}else{
return i + getSum(i -1);
}
}
递归的练习题
需求 : 用递归求5的阶乘,并把结果输出在控制台
5! = 5 * 4 * 3 * 2 * 1
5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1
代码实现:
public static int jc(int i) { // 作用：计算i的阶乘
if(i == 1) {
return 1 ;
}else {
return i * jc(i - 1) ;
}
}
8.5 快速排序
快速排序概述
冒泡排序算法中,一次循环结束,就相当于确定了当前的最大值,也能确定最大值在数组中应存入的位置
快速排序算法中,每一次递归时以第一个数为基准数,找到数组中所有比基准数小的.再找到所有比基准数大的,小的全部放左边,大的全部放右边,确定基准数的正确位置
核心步骤
- 从右开始找基准数小的
- 从左开始找基准数大的
- 交换两个值的位置
- 红色继续往左找,蓝色继续往右找,直到两个箭头指向同一个索引
- 基准数归位
代码实现:
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);
}
}
8.6 Arrays(应用)
Arrays的常用方法
示例代码
public class MyArraysDemo {
public static void main(String[] args) {
// public static String toString(int[] a) 返回指定数组的内容的字符串表示形式
// int [] arr = {3,2,4,6,7};
// System.out.println(Arrays.toString(arr));
// public static void sort(int[] a) 按照数字顺序排列指定的数组
// int [] arr = {3,2,4,6,7};
// Arrays.sort(arr);
// System.out.println(Arrays.toString(arr));
// public static int binarySearch(int[] a, int key) 利用二分查找返回指定元素的索引
int [] arr = {1,2,3,4,5,6,7,8,9,10};
int index = Arrays.binarySearch(arr, 0);
System.out.println(index);
//1,数组必须有序
//2.如果要查找的元素存在,那么返回的是这个元素实际的索引
//3.如果要查找的元素不存在,那么返回的是 (-插入点-1)
//插入点:如果这个元素在数组中,他应该在哪个索引上.
}
}
工具类设计思想
- 构造方法用private修饰
- 成员用public static修饰
扫一扫
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
