权限修饰符和代码块

权限修饰符：使用的范围

代码块：

局部代码块

给代码单独的一个大括号
变量只在所属的大括号中有效，局部代码块可以把他废了

构造代码块

将多个构造方法中的重复代码块抽取出来
写在成员位置中的代码块

静态代码块

执行时机：随着类的加载而加载并且只执行一次
eg：
添加一些用户信息

抽象类和抽象方法

在父类中，如果一个方法在子类中有不同写法，就用抽象类，否则重写容易忘记，这是重写的弊端

如果不重写就会报错

接口Interface

可以理解为一种规则

接口就是一种规则

获取成员内部类对象的两种方式：
方式一：外部类编写方法，对外提供内部类对象
方式二：直接创建
格式：外部类名.内部类名对象名=外部类对象.内部类对象；
范例：Outer.Inner oi = new Outer().new Inner();

crtl+alt+m抽象成方法

setLayout（null）取消掉默认的放置

随机打乱

通过数组先随机打乱，再放到多维数组中

给二维数组添加数据

两种方法：

隐藏容器：
Jfram. getContentPane

常用API

cmd命令eg：
shutdown：关机

system

‘把arr1数组中的数据拷贝到arr2中
参数一：数据源，要拷贝的数据从哪个数组而来
参数二：从数据源数组中的第几个索引开始拷贝
参数三：目的地，我要把数据拷贝到哪个数组中
参数四：目的地数组的索引。
参数五：拷贝的个数

Biginteger

bigtinterger 必须是整数，否则会报错

静态方法获取biginteger的对象，内部有优化
1.能表示的范围表比较小，只能在long的取值范围之内
2.在内部常用的数字-16~16进行了优化，如果多次获取不会重新创建新的

BigInteger bd5 = BigInteger.valueof(100);
System.out.println(bd5);

对象方法

add加
multiply乘法
divide除法
divideAndReminder获取商和余数
特殊：

转为int类型整数，超出范围数据有误

BigInteger bd6 = BigInteger.valueOf(2147483647L);
int i = bd6.intValue();
System.out.println(i);

BigDecima

bigdecima特殊的两个方法：（其余和Biginteger类似）

正则表达式

startsWith（）可用来检验开头的字符
charAt（）
正则表达式用法：
qq.matches（“正则表达式”）

爬虫

Pattern:表示正则表达式
Matcher：文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。
在大串中去找符合匹配规则的子串。

待条件的爬取

?理解为前面的数据Java
=表示在Java后面要跟随的数据
但是在获取的时候，只获取前半部分

eg：
需求1: 爬取版本号为8,11,17的Java文本,但是只要Java,不显示版本号。
需求2：爬取版本号为8,11,17的Java文本。正确爬取结果为：Java8Java11Java17Java17
需求3：爬取除了版本号为8,11,17的Java文本，

//需求1：
String regex1 ="((?i)Java)(?=8|11|17)";
//需求2：
String regex2 = "((?i)Java)(8|11|17)";
//需求3:
String regex3 = "((?i)Java)(?:8|11|17)";
String regex = "Java(?=8|11|17)";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
while(m.find()){
System.out.println(m.group());

贪婪爬取与非贪婪爬取

ab+:
贪婪爬取：abbbbbbbbbbbb
非贪婪爬取：ab
Java当中，默认的就是贪婪爬取
如果我们在数量词+*的后面加上问号，那么此时就是非贪婪爬取

识别正则

JDK时间

//1.创建对象表示一个时间
Date d1 = new Date();
//System.out.println(d1);
//2.创建对象表示一个指定的时间
Date d2 = new Date(OL);
System.out.println(d2);
//3.setTime 修改时间
//1000毫秒=1秒
d2.setTime(1000L);
System.out.println(d2);//4.getTime获取当前时间的毫秒值
long time = d2.getTime();
System.out.println(time);

SimpleDateFormat类

/*假设，你初恋的出生年月日为：2000-11-11
请用字符串表示这个数据，并将其转换为：2000年11月11日
创建一个Date对象表示2000年11月11日
创建一个SimpleDateFormat对象，并定义格式为年月日
把时间变成：2000年11月11日
*/
//1.可以通过2000-11-11进行解析，解析成一个Date对象
String str = "2000-11-11";
//2.解析
SimpleDateFormat sdf1 = new SimpleDateFormat( pattern: "yyyy-MM-dd");
Date date = sdf1.parse(str);
//3.格式化
SimpleDateFormat sdf2=new SimpleDateFormat(pattern:"yyyy年MM月dd日");
String result = sdf2.format(date);
System.out.println(result);

Calendar

细节：calendar是一个抽象类，不能直接new，而是通过一个静态方法获取到子类对象
底层原理：
会根据系统的不同时区来获取不同的日历对象，默认表示当前时间。
把会把时间中的纪元，年，月，日，时，分，秒，星期，等等的都放到一个数组当中
细节2：
月份：范围e~11如果获取出来的是e.那么实际上是1月。|
星期：在老外的眼里，星期日是一周中的第一天1（星期日）2（星期一）3(星期二)4（星期三）5（星期四）6（星期五）
7（星期六）

如何让返回的数字变成字母，表示星期的5变成汉字"星期四"

通过定义一个数组，将返回的值，与星期一一对应，（查表法）

//查表法：
//表：容器
//让数据跟索引产生对应的关系
//传入对应的数字：1～7
//返回对应的星期
public static String getWeek(int index){
//定义一个数组，让汉字星期几跟1~7产生对应关系
String[]arr={""，"星期日"，"星期一"，"星期二"，"星期三"，"星期四"，"星期五"，"星期六"}；
//根据索引返回对应的星期
return arr[index];

JDK8新增

包装类

//将字符串类型的整数转成int类型的整数
//强类型语言：每种数据在java中都有各自的数据类型
//在计算的时候，如果不是同一种数据类型，是无法直接计算的。
int i = Integer.parseInt(s: "123");|
System.out.println(i);
System.out.println(i + 1);//124
//细节1：
//在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
//细节2：
//8种包装类当中，除了character都有对应的parsexxx的方法，进行类型转换
String str = "true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);

键盘录入

//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");|
// String str = sc.next();
System.out.println(str);*/
//弊端：
//当我们在使用next，nextInt，nextDouble在接收数据的时候，遇到空格，回车，制表符的时候就停止了
//键盘录入的是123123那么此时只能接收到空格前面的数据
//我想要的是接收一整行数据
//约定：
//以后我们如果想要键盘录入，不管什么类型，统一使用nextLine
//特点遇到回车才停止
String line = sc.nextLine();
System.out.println(line);

常见算法

二分法算法改进（斐波那契额查找）

分块查找

分块的原则1：前一块中的最大数据，小于后一块中所有的数据（块内无序，块间有序）
分块的原则2：块数数量一般等于数字的个数开根号。比如：16个数字一般分为4块左右。
核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找。
方法：

1.创建块的对象：

Block b1=new Block（ 21，0,5）
Block b1=new Block（ 45，6,11）
Block b1=new Block（ 73，12,17)

2.定义数组管理三个快的对象
3.定义一个变量用来记录要查找的元素
int number = 30;
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.获取这一块的起始索引和结束索引
// Block b1 = new Block(21,0,5);
// Block b2 = new Block(45,6,11);
// Block b3 = new Block(73,12,17);
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;
}//定义一个方法，用来确定number在哪一块当中
public static int findIndexBlock(Block[] blockArr,int number){ //100
//从e索引开始遍历blockArr,如果number小于max,那么就表示number是在这一块当中的
for (int i = 0; i < blockArr.length; i++) {
if(number <= blockArr[i].getMax()){
return i;
}
}
return -1;
}
}

冒泡排序

选择排序

插入排序

快速排序

public static void quickSort(int[] arr, int i, int j) {
/定义两个变量记录要查找的范围
int start = i;
int end = j;
//递归出口
if(start>end){
return;
}
//记录基准数
int baseNumber = arr[i];
∥利用循环找到要交换的数字
while(start != end){
//利用end，从后往前开始找，找比基准数小的数字
while(true){
if(end <= start || arr[end]< baseNumber){
break;
}
end--;
}
//利用start，从前往后找，找比基准数大的数字
while(true){
if(end <= start || arr[start] > baseNumber){
break;
}
start++;
}
//把end和start指向的元素进行交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
//当start和end指向了同一个元素的时候，那么上面的循环就会结束
//表示已经找到了基准数在数组中应存入的位置
//基准数归位
//就是拿着这个范围中的第一个数字，跟start指向的元素进行交换
int temp = arr[i];
arr[i] = arr[start];
arr[start] = temp;
//确定6左边的范围，重复刚刚所做的事情
quickSort(arr,i, j: start - 1);
//确定6右边的范围，量复刚刚所做的事情
quickSort(arr, i: start + 1,j);

常见算法的API-Arrays

binarySearch:二分查找法查找元素

细节1：二分查找的前提：数组中的元素必须是有序，数组中的元素必须是升序的
细节2：如果要查找的元素是存在的，那么返回的是真实的索引
但是，如果要查找的元素是不存在的，返回的是-插入点-1
疑问：为什么要减1呢?
解释：如果此时，我现在要查找数字0，那么如果返回的值是-插入点，就会出现问题了。
如果要查找数字0，此时是不存在的，但是按照上面的规则-插入点，应该就是-e
为了避免这样的情况，Java在这个基础上又减一。

copyof:拷贝数组

参数一：老数组
参数二：新数组的长度
方法的底层会根据第二个参数来创建新的数组
如果新数组的长度是小于老数组的长度，会部分拷贝
如果新数组的长度是等于老数组的长度，会完全拷贝
如果新数组的长度是大于老数组的长度，会补上默认初始值

Lambda表达式