java185
常用API-01-Math
常用API-03-System
public static void exit(int status)
终止当前运行的 Java 虚拟机
public static long currentTimeMillis()返回当前系统的时间毫秒值形式
public static void arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)
数组拷贝
//拷贝数组
int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
int[] arr2 = new int[10];
//把arr1数组中的数据拷贝到arr2中
//参数一:数据源，要拷贝的数据从哪个数组而来
//参数二:从数据源数组中的第几个索引开始拷贝
//参数三:目的地，我要把数据拷贝到哪个数组中
//参数四:目的地数组的索引。
//参数五:拷贝的个数
system.arraycopy( arr1, srcPos: 0 ,arr2 , destPos: 0 ,length: 5);
//验证
for ( int i = 0; i < arr2.length; i++) {
system.out.print( arr2[i] +" ");
}
细节:
1.如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
2.在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
3.如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型
- System:也是一个工具类，提供了一些与系统相关的方法
- 时间原点:1970年1月1日0:0:0，我国在东八区，有8小时时差。
- 1秒= 1000毫秒
- 常见方法如下:
- exit:停止虚拟机
- currentTimeMillis:获取当前时间的毫秒值
- arraycopy:拷贝数组
常用API-04-Runtime
7.运行cmd命令shutdown :关机加上参数才能执行
-s :默认在1分钟之后关机
-s -t指定时间:指定关机时间
-a:取消关机操作
-r :关机并重启
Runtime.getRuntime( ).exec( command: “shutdown -s -t 3600” );
常用API-05-Object
object
Object是Java中的顶级父类。所有的类都直接或间接的继承于Object类。
System:类名
out:静态变量
System.out:获取打印的对象
Println( ):方法
参数:表示打印的内容
核心逻辑:
当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串。然后再打印在控制台上，打印完毕换行处理。
toString方法的结诱:
如果我们打印一个对象，想要看到属性值的话，那么就重写tostring方法就可以了。在重写的方法中，把对象的属性值进行拼接。
public string toString()
返回对象的字符串表示形式
public boolean equals(object obj)
比较两个对象是否相等
protected obiect clone(int a)
对象克隆
常用API-06-浅克隆、深克隆和对象工具.
Cloneable
如果一个接口里面没有抽象方法
表示当前的接口是一个标记性接口
现在Cloneable表示一旦了实现，那么当前类的对象就可以被克隆
如果没有实现，当前类的对象就不能克隆
//1.先创建一个对象
int[] data = {1，2，3，4，5，6，7，8，9，10，11，12，13，14，15，0};
User u1 = new User( id: 1, username:"zhangsan", password:"1234qwer" , path: "girl11",data);
//2.克隆对象
User u2 = (user) u1.clone();
细节:
方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去。
书写细节:
1.重写object中的clone方法
2.让javabean类实现cloneable接口
3.创建原对象并调用clone就可以了。
浅克隆
不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来
基本数据类型拷贝过来
深克隆
字符串复用
引用数据类型会重新创建新的
深克隆
protected object clone( ) throws CloneNotSupportedException {
//调用父类中的clone方法
//相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。
//先把被克隆对象中的数组获取出来
int[ ] data = this.data;
//创建新的数组
int[ ] newData = new int[data.length];//拷贝数组中的数据
for (int i = 0; i < data.length; i++) {
newData[i] = data[i];
}
//调用父类中的方法克隆对象
User u = (User) super.clone( );
//因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
u.data = newData;
return u;
}
-
Object是Java中的顶级父类。
所有的类都直接或间接的继承于Object类。 -
tostring():一般会重写，打印对象时打印属性
-
equals():比较对象时会重写，比较对象属性值是否相同
-
clone():默认浅克隆。
如果需要深克隆需要重写方法或者使用第三方工具类。toString()方法重写
重写toString()方法可以让我们自定义对象转换为字符串的方式，这在拷贝对象时非常有用。通常情况下，toString()方法返回的是对象的类名和一些标识性信息，如对象的地址等。重写toString()方法可以让我们返回对象的属性值，从而方便我们查看和调试程序。
例如，假设我们有一个Person类，它有name，age和gender三个属性，我们可以按照如下方式重写toString()方法：
public class Person {
private String name;
private int age;
private String gender;
// getters and setters
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
'}';
}
}
equals()方法重写
重写equals()方法可以让我们自定义对象比较的方式，从而实现更细粒度的控制。equals()方法用于比较两个对象是否相等，通常情况下，它比较的是对象的引用地址。但是在某些情况下，我们可能需要比较对象的属性值或者其他标识符来判断对象是否相等。
例如，假设我们有一个Person类，它有name和idNumber两个属性。我们可以按照如下方式重写equals()方法：
public class Person {
private String name;
private String idNumber;
// getters and setters
@Override
public boolean equals(Object obj) {
if (obj == this)
return true;
if (!(obj instanceof Person))
return false;
Person person = (Person) obj;
return idNumber.equals(person.idNumber);
}
}
objects
常用API-O7-Biglnteger基本使用和原理…
//1.获取一个随机的大整数
//1.获取一个随机的大整数
Random r = new Random( );
for (int i = 0; i < 100; i++) {
BigInteger bd1 = new BigInteger( 4,r);
System.out.print1n( bd1);//[0 ~ 15]}
2.获取一个指定的大整数
//2.获取一个指定的大整数
//细节:字符串中必须是整数，否则会报错
BigInteger bd2 = new BigInteger( "1.1");
system.out.print1n(bd2);
BigInteger bd3 = new BigInteger ( "abc" );
system.out.println(bd3 ) ;
3.获取指定进制的大整数
// 3.获取指定进制的大整数
//细节:
//1.字符串中的数字必须是整数
//2.字符串中的数字必须要跟进制吻合。
//比如二进制中，那么只能写e和1，写其他的就报错。
BigInteger bd4 = new BigInteger( "123",2);
system.out. println( bd4 ) ;
4.静态方法获取BigInteger的对象，内部有优化
//4.静态方法获取BigInteger的对象，内部有优化
BigInteger bd5 = BigInteger.valueof( 100 ) ;
system.out.println( bd5 );
个
常用API-08-BigDecima基本使用和原理…
构造方法获取BigDecimal对象
public BigDecimal( double val)public BigDecimal( string val)
静态方法获取BigDecimal对象
public static BigDecimal valueOf( double val)
1.通过传递double类型的小数来创建对象//细节:
这种方式有可能是不精确的，所以不建议使用
BigDecimal bd1 = new BigDecimal( val: e.01);
BigDecimal bd2 = new BigDecimal( val: e.e9) ;
system.out.println(bd1);
system.out.println( bd2);
2.通过传递字符串表示的小数来创建对象
BigDecimal bd3 = new BigDecimal( val: "0.01" );
BigDecimal bd4 = new BigDecimal( val: "0.09" );
BigDecimal bd5 = bd3.add( bd4);
system.out.println(bd3);
system.out.print1n(bd4);
system.out.println(bd5);
3.通过静态方法获取对象
BigDecimal bd6 = BigDecimal.valueof ( 10);
system.out.println(bd6) ;
1.如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
2.如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
3.如果我们传递的是0~10之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new
UP:远离零方向舍入的舍入模式
DoWN:向零方向舍入的舍入模式
CEILING:向正无限大方向舍入的舍入模式
FLOOR:向负无限大方向舍入的舍入模式
正则表达式
// \表示转义字符
// \前面的\是一个转义字符，改变了后面\原本的含义，把他变成一个普普通通的\而已。
常用API-12-爬虫
Pattern:表示正则表达式
Matcher:文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。
在大串中去找符合匹配规则的子串。
//获取正则表达式的对象
Pattern p = Pattern.compile( "Java\\d{0,2]" );
//获取文本匹配器的对象
//m:文本匹配器的对象
// str:大串
// p:规则
//m要在str中找符合p规则的小串
Matcher m = p.matcher( str);
//拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
//如果没有，方法返回false
//如果有，返回true。在底层记录子串的起始索引和结束索引+1
//0,4
boolean b = m.find( );
//方法底层会根据find方法记录的索引进行字符串的截取
// substring(起始索引，结束索引);包头不包尾
// (0,4),但是不包含4索引
//会把截取的小串进行返回。
String s1 = m.group();
System.out.println(s1);
//1.获取正则表达式的对象
Pattern p = Pattern.compile( "Java\\d{0,2}");
//2.获取文本匹配器的对象
//拿着m去读取str，找符合p规则的子串
Matcher m = p.matcher(str);
//3.利用循环获取
while(m.find( )){
string s = m.group();
system.out.println( s );
}
String s = "java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和JAva11，" +
"因为这两个是长期支持版本，下一个长期支持版本是JAVa17，相信在未来不久JAVA17也会逐渐登上历史舞台";
//1.定义正则表达式
//?理解为前面的数据Java
//=表示在Java后面要跟随的数据
//但是在获取的时候，只获取前半部分
string regex = "((?i)Java)(?=8|11|17)" ;
string regex2 ="((?i)Java)(8|11|17)";
string regex3= "((?i)Java)(?:8|11|17)";//包含所有
string regex4 = "((?i)Java)(?!8|11|17)";//除了
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s );
while(m.find() ){
system.out.println(m.group());
}
}
只写+和*表示贪婪匹配
+?非贪婪匹配
?非贪婪匹配
贪婪爬取:在爬取数据的时候尽可能的多获取数据非贪婪爬取:
在爬取数据的时候尽可能的少获取数据
Java当中，默认的就是贪婪爬取
如果我们在数量词+ 的后面加上问号，那么此时就是非贪婪爬取
常用API-14-捕获分组和非捕获分组
string regex1 = "(.).+\\1";
\组号:表示把第x组的内容再出来用一次
-JDK7时间-Date
JDK7前时间相关类
Date
时间
simpleDateFormat
格式化时间
calendar
日历
1秒=1000毫秒
1毫秒=1000微秒
1微秒=1000纳秒
public Date( )
创建Date对象，表示当前时间
public Date( long date)
创建Date对象，表示指定时间
public void setTime( long time)
设置/修改毫秒值
public long getTime( )
获取时间对象的毫秒值
SimpleDateFormat类作用
格式化:把时间变成我们喜欢的格式。
解析:把字符串表示的时间变成Date对象。
//1.利用空参构造创建simpleDateFormat对象，默认格式
simpleDateFormat sdf = new SimpleDateFormat( );
Date d = new Date(eL);
string str = sdf.format(d);
system.out.println(str);//1970/1/1 上午8:00
常用API-17-JDK7时间-Calendar
Calendar概述
calendar代表了系统当前时间的日历对象，可以单独修改、获取时间中的年，月，日
●细节:Calendar是一个抽象类，不能直接创建对象。
星期:在老外的眼里，星期日是一周中的第一天
1（星期日)
2（星期一)
3 (星期二)
4（星期三）
5（星期四
6 (星期五）
7 (星期六)
把会把时间中的纪元，年，月，日，时，分，秒，星期，等等的都放到一个数组当中
0:纪元
1:年
2:月
3:一年中的第几周4:一个月中的第几周
5:一个月中的第几天（日期)
包装类
如何理解包装类?
包装类:基本数据类型对应的引用类型
//3.这两种方式获取对象的区别（掌握)
//因为在实际开发中，-128~127之间的数据，用的比较多。
//如果每次使用都是new对象，那么太浪费内存了
//所以，提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的，而是返回已经创建好的对象。
Integer i6 = Integer.valueof(127);
Integer i7 =Integer.vaLueOf(127);
system.out.println(i6 ==i7);
//true
Integer i8 =Integer.valueof(128);
Integer i9 = Integer.valueof(128);
system.out.print1n(i8 ==i9);
//false
在JDK5的时候提出了一个机制:自动装箱和自动拆箱
自动装箱:把基本数据类型会自动的变成其对应的包装类
自动拆箱:把包装类自动的变成其对象的基本数据类型
//在底层，此时还会去自动调用静态方法valueof得到一个Integer对象，只不过这个动作不需要我们自己去操作了
//自动装箱的动作
Integer i1 = 10;
Integer i2 = new Integer( value: 10);
//自动拆箱的动作
int i = i2;
我们以后如何获取包装类对象?
不需要new，不需要调用方法，直接赋值即可
Integer i1 = 10;
Integer i2 = 10;
Integer i3= i1+i2
//以后我们如果想要键盘录入，不管什么类型，统一使用nextLine
//特点遇到回车才停止
string line = sc.nextLine();system.out.println(line);
int i Integer.parseInt(line);
二分查找/折半查找
1, min和max表示当前要查找的范围
2,mid是在min和max中间的
3，如果要查找的元素在mid的左边，缩小范围时，min不变，max等于mid减1
4，如果要查找的元素在mid的右边，缩小范围时，max不变，min等于mid加1
1.二分查找、插值查找，斐波那契额查询各自的特点
相同点:
都是通过不断的缩小范围来查找对应的数据的
不同点:
计算mid的方式不一样
二分查找: mid每次都是指向范围的中间位置
插值查找: mid尽可能的靠近要查找的数据，但是要求数据尽可能的分布**均匀斐波那契额查找:**根据黄金分割点来计算mid指向的位置
常见算法-02-分块，分块扩展，哈希查找
分块的原则1:
前一块中的最大数据，小于后一块中所有的数据（块内无序，块间有序)
分块的原则2:
块数数量一般等于数字的个数开根号。比如:16个数字一般分为4块左右
//利用分块查找的原理，查询number的索引
private static int getIndex(Block[] blockArr， int[] arr, int number){
//1.确定number是在那一块当中
int indexBlock = findIndexBLock( blockArr， number);
if(indexBlock == -1){
//表示number不在数组当中return -1;
}
//2.获取这一块的起始索引和结束索引 ---- 30
// Block b1 = new Block(21,0,5); ---- 0
// Block b2 = new Block(45,6,11); ---- 1
// Block b3 = new Block(73,12,17); ---- 2
int startIndex = blockArr[indexBlock].getStartIndex( );
int endIndex = blockArr[indexBlock].getEndIndex();
//3.遍历
for (int i = startIndex; i <= endIndex; i++){
if(arr[i] == number){
return i;
}
}
return -1;
}
常见算法-03-冒泡排序和选择排序
//1.定义数组
int[ ] arr = {2,4,5,3,1};
//2.利用冒泡排序将数组中的数据变成1 2 3 4 5
//第一轮:
//结束之后，最大值在数组的最右边. . . . 5
//外循环:表示我要执行多少轮、如果有n个数据，那么执行n - 1轮
for (int i = e; i < arr.length - 1; i++)(
for (int j = e; j < arr.length - 1 - i; j++) {
//i 依次表示数组中的每一个索引:0 1 2 3 4
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[i] = arr[ji + 1];
arr[j + 1] = temp;
}
}
//最终代码:
//外循环:几轮
//i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
for (int it- e; i < arr.length -1; i++) i
//内循环:每一轮我要干什么事情?
//拿着i跟i后面的数据进行比较交换
for (int j = i + 1;j < arr.length; j++) {
if(arr[i] > arr[i]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
常见算法-04-插入排序和递归算法
int[] arr = {3，44，38,5,47，15，36，26，27，2，46，4，19，50，48];
//1.找到无序的哪一组数组是从哪个索引开始的。2
int startIndex = -1;
for (int i = o; i < arr.length; i++) {
if(arr[i] > arr[i + 1]){
startIndex = i + 1;
break;
}
}
//2.遍历从startIndex开始到最后一个元素，依次得到无序的哪一组数据中的每一个元素
for (int i = startIndex; i < arr.length; i++) {
//问题:如何把遍历到的数据，插入到前面有序的这一组当中
//记录当前要插入数据的索引
int j = i;
while(j > e && arr[i] < arr[i - 1]){
//交换位置
int temp = arr[i];
arr[i] = arr[j - 1];
arr[j - 1] = temp;
j--;
}
递归算法
递归指的是方法中调用方法本身的现象。
递归算法的作用
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
书写递归的两个核心:
- 找出口:什么时候不再调用方法。
- 找规则:如何把大问题变成规模较小的问题
public class A04_RecursionDemo2 {
public static void main( String[] args) {
//需求:利用递归求1-108之间的和
//100 + 99 + 98 + 97 + 96 + 95 .... +2 +1
//大问题拆解成小问题
//1~108之间的和 = 100 +(1~99之间的和>
//1~99之间的和 = 99 +(1~98之间的和)
//1~98之间的和= 98 +(1~97之间的和>
//。。。
//1~2之间的和 = 2 +(1~1之间的和)
//1~1之间的和= 1（递归的出口)
//核心:
//1.找出口//2.找规律
System.out.println(getsum( numbor 100))
}
public static int getSum( int number){//99
if(number == 1){
return 1;
}
//如果numbert不是1呢?
return number + getsum( number: number -1);
常见算法-05-快速排序
快速排序
第一轮:把0索引的数字作为基准数，确定基准数在数组中正确的位置。
比基准数小的全部在左边，比基准数大的全部在右边。
lambda表达式
method(new Swim() {
@override
public void swimming ) {
system.out.println("正在游泳~~~");
}
});
method(
()->{
system.out.println("正在游泳~~~") ;
);
// lambda完整格式
Arrays.sort(arr,(Integer o1，Integer o2) -> {
return o1 - o2;
}
);
// lambda省略写法
Arrays.sort( arr,(o1,o2) -> o1 - o2);
集合进阶-01-单列集合顶层接口Collection
public boolean add(E e)添加
public void clear()清空
public booleanremove(E e)删除
public boolean contais ( Object obj)判断是否包含
public boolean isEmpty()判断是否为空
public int size()集合长度
注意点:
collection是一个接口,我们不能直接创建他的对象。
所以,现在我们学习他的方法时，只能创建他实现类的对象。
实现类: ArrayList
3.删除
细节1:因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
细节2:方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false
如果要删除的元素不存在，就会制除失败。
4.判断元素是否包含
/细节:底层是依赖equals方法进行判断是否存在的。
//所以，如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法。
alt+insert(equals)