https://www.bilibili.com/video/BV1fh411y7R8/?p=110&spm_id_from=333.880.my_history.page.click&vd_source=92305fa48ea41cb7bedb3ab5e056d42d
韩顺平老师在b站课的链接。
010，JDK的介绍
018，Java开发细节
6，一个源文件中最多只能有一个public类。其他类的个数不限。
public class test1 {
public static void main(String[] args){
System.out.println("hello world");
}
}
class Dog{
}
class Cat{
}
编译后，每一个类都对应一个.class文件
7，如果源文件包含一个public类，则文件名必须按该类名命名！
8，一个源文件中最多只能有一个public类。其他类的个数不限，也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法
public class test1 {
public static void main(String[] args){
System.out.println("hello world");
}
}
class Dog{
public static void main(String[] args){
System.out.println("dog");
}
}
class Cat{
public static void main(String[] args){
System.out.println("cat");
}
}
比如指定运行Dog类
019，学习方法
028，DOS指令
DOS：Disk Operating System 磁盘操作系统。
常用的dos命令
1，查看当前目录是有什么 dir 。
比如查看 d盘下的java文件夹里有啥，dir d:\java
2,切换到其他盘下，cd
比如当前盘是c盘，切换到d盘下，cd /D d:
3，切换到当前盘的其他目录下，cd ，用相对路径和绝对路径都可以
相对路径是指从根目录开始的目录，比如当前盘是d盘,切换到d盘java文件夹下的jetbra文件夹下，cd d:\java\jetbra
绝对路径是指从当前文件夹开始的路径，比如当前盘是d盘,切换到d盘java文件夹下的jetbra文件夹下，cd ..\..\java\jetbra，..\表示上一级目录，如果是顶级目录，写了也不会报错。
4，切换到上一级，cd ..
5，切换到根目录，cd \
6，查看指定的目录下所有的子级目录，tree 文件路径
7，清屏 cls [简记：苍老师]
8，退出DOS，exit
051，自动类型转换
1，有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。以下代码经过编译后才判断出对错。
int n1 = 10;
float d1 = n1 + 1.1; //错误，1.1默认是double类型，自动类型转换后，计算结果d1是double类型
double d1 = n1 + 1.1; //对
float d1 = n1 + 1.1f; //对
2，当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。
int n2 = 1.1; //错误，1.1是double类型，精度大，n2是int类型，精度小，只能是小转换成大的
3，（byte，short）和 char 之间不会相互自动转换。
byte b1 = 10;//对，原因：当把具体数赋给byte时，先判断该数是否在byte范围内，如果是就可以。
int n2 = 1;
byte b2 = n2;//错误，原因：如果是变量赋值，判断类型
char c1 = b1;//错误，原因：byte不能自动转成char
4，byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。
byte b2 = 1;
byte b3 = 2;
short s1 = 1;
short s2 = b2 + s1;//错，b2+s1结果是int
int s2 = b2 + s1;//对
byte b4 = b2 + b3;//错，b2+b3结果是int
5，boolean 不参与转换
boolean pass = true;
int num = pass;//错
6，自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型
byte b4 = 1;
short s3 = 100;
int num1 = 1;
double num2 = 1.1;
double num3 = b4 + s3 + num1 + num2;//对
054，强制类型转换
1，当进行数据的大小从 大 -------> 小，就需要使用到强制转换
2，强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
int x = (int)(10*3.5+6*1.5);// (int)44.0 -> 44
3，char 类型可以保存 int 的常量值，但不能保存 int 的变量值（自动类型转换讲过），需要强转
char c1 = 100;//对
int m = 100; //对
char c2 = m;//错
char c3 = (char)m; //对
4，byte 和 short 类型在进行运算时，当做 int 类型处理（自动类型转换讲过）
085，键盘输入
案例演示：要求可以从控制台接收用户信息（姓名，年龄，薪水）
import java.util.Scanner;//表示把java.util下的Scanner类导入
public class test1 {
public static void main(String[] args){
Scanner myScanner = new Scanner(System.in);//创建Scanner 对象
System.out.println("请输入名字");
String name = myScanner.next();//接收用户输入字符串
System.out.println("请输入年龄");
int age = myScanner.nextInt();//接收用户输入int
System.out.println("请输入薪水");
double sal = myScanner.nextDouble();//接收用户输入double
System.out.println("名字是：" + name + "年龄是：" + age + "薪水是：" + sal);
}
}
运行结果：
136，空心金字塔
请编写一个程序，可以接收一个整数，表示层数（totalLevel），打印出空心金字塔。【化繁为简，先死后活】
1，先打印一个矩形
public class test1 {
public static void main(String[] args){
for(int i = 1; i <= 5; i++)
{
System.out.println("*****");
}
}
}
运行结果：
2，打印半个金字塔
public class test1 {
public static void main(String[] args){
for(int i = 1; i <= 5; i++) //i 表示层数
{
for(int j = 1; j <= i; j++) //控制打印每层的 * 个数，不能超过层数
{
System.out.print("*"); //这里不能换行输入*,不用println
}
System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
}
}
}
运行结果：
3，打印整个金字塔
public class test1 {
public static void main(String[] args){
for(int i = 1; i <= 5; i++) //i 表示层数
{
for(int j = 1; j <= 2 * i - 1; j++) //控制打印每层的 * 个数，不能超过层数
{
System.out.print("*"); //这里不能换行输入*,不用println
}
System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
}
}
}
运行结果：
3，打印整个金字塔（ * 前加空格）
public class test1 {
public static void main(String[] args){
for(int i = 1; i <= 5; i++) //i 表示层数
{
for(int k = 1; k <= 5 - i; k++)//在输出*之前，还有输出 对应空格 = 总层数-当前层
{
System.out.print(" ");//这里是一个空格
}
for(int j = 1; j <= 2 * i - 1; j++) //控制打印每层的 * 个数，不能超过层数
{
System.out.print("*"); //这里不能换行输入*,不用println
}
System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
}
}
}
运行结果：
4，打印空心的金子塔
public class test1 {
public static void main(String[] args){
for(int i = 1; i <= 5; i++) //i 表示层数
{
for(int k = 1; k <= 5 - i; k++)//在输出*之前，还有输出 对应空格 = 总层数-当前层
{
System.out.print(" ");//这里是一个空格
}
for(int j = 1; j <= 2 * i - 1; j++) //控制打印每层的 * 个数，不能超过层数
{
if(j == 1 || j == 2 * i - 1 || i == 5)//当前行的第一个位置是*，最后一个位置也是*，最后一层全部*
{
System.out.print("*"); //这里不能换行输入*,不用println
}
else //其他情况输出空格
{
System.out.print(" ");
}
}
System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
}
}
}
运行结果：
先死后活：层数 5 做成变量 int totalLevel = 5;
149，本章作业3
1，输出1-100之间的不能被5整除的数，每5个一行。
难点：每5个一行，使用 int count 统计输出的个数，当 count % 5 = 0 就说明输出了5个。
public class test1 {
public static void main(String[] args) {
int count = 0;
for(int i = 1; i <= 100; i++)
{
if(i % 5 != 0)
{
count++;
System.out.print(i +"\t");//这里不用换行
if(count % 5 == 0)//判断每满5个，就输出一个换行
{
System.out.println();
}
}
}
}
}
运行结果：
150，本章作业4
1，输出小写的 a-z 以及大写的 Z-A
a的Ascll码是97，对应着字符a，97加1就是98，对应着字符b....，所以用for循环从'a' 到 'z'。'a'是char类型，本质是整数。
public class test1 {
public static void main(String[] args) {
for(char c1 = 'a'; c1 <= 'z'; c1++)//'b' = 'a' + 1，c = 'a' + 2
{
System.out.print(c1 + " ");
}
System.out.println();
for(char c1 = 'Z'; c1 >= 'A'; c1--)
{
System.out.print(c1 + " ");
}
}
}
运行结果：
152，本章作业6
1，求 1+（1+2）+（1+2+3）+（1+2+3+4）+...+（1+2+3+..+100) 的结果。
观察式子，发现第一项到最后一项有100个，第二项是（1+2），数字在逐渐增加，第二项也对应着其中的最后一个数字2。
public class test1 {
public static void main(String[] args) {
int sum = 0;
for(int i = 1; i <= 100; i++)//i 可以表示是第几项，同时也是当前项的最后一个数
{
for(int j = 1; j <= i; j++) //内层对 1到 i 进行循环
{
sum += j;
}
}
System.out.println(sum);
}
}
运行结果：
162，数组练习2
1，请求出一个数组 int[] 的最大值 {4,-1,9,10,23}，并得到对应的下标。
思路：（1）假定 max = arr[0] 是最大值，maxIndex = 0，
（2）从下标 1 开始遍历 arr，如果 max < 当前元素，说明 max 不是真正的最大值，我们就 max = 当前元素；maxIndex = 当前元素下标
（3）当我们遍历这个数组 arr 后，max 就是真正的最大值，maxIndex 是最大值对应的下标
public class test1 {
public static void main(String[] args) {
int[] arr = {4,-1,9,10,23};
int max = arr[0]; //假定数组arr第一个元素就是最大值
int maxIndex = 0;
for(int i = 1; i < arr.length; i++) //i的最大值是arr.length - 1,从下标 1 开始遍历arr
{
if(max < arr[i]) //如果max < 当前元素
{
max = arr[i]; //把 max 设置成当前元素
maxIndex = i;
}
}
System.out.println(max);
System.out.println(maxIndex);
}
}
运行结果：
163，数组赋值机制(引用赋值）
基本数据类型赋值，赋值方式为值拷贝。n2的变化，不会影响到n1的值。
public class test1 {
public static void main(String[] args) {
int n1 = 10;
int n2 = n1;
n2 = 80;
System.out.println("n1 = " + n1);
System.out.println("n2 = " + n2);
}
}
运行结果：
数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值。arr2变化会影响到arr1。
public class test1 {
public static void main(String[] args) {
int[] arr1 = {1,2,3};
int[] arr2 = arr1;
arr2[0] = 10;
for(int i = 0; i < arr1.length; i++)
{
System.out.print(arr1[i] + " ");
}
}
}
运行结果：
166，数组反转1（通过找规律反转）
1，把数组的元素内容反转
arr = {1,2,3,4,5,6} -----> arr = {6,5,4,3,2,1}
类似于两个装着不同饮料的杯子，互相交换，需要借助一个空杯子。
规律：
（1），把 arr[0] 和 arr[5] 进行交换，{6,2,3,4,5,1}
（2），把 arr[1] 和 arr[4] 进行交换，{6,5,3,4,2,1}
（3），把 arr[2] 和 arr[3] 进行交换，{6,5,4,3,2,1}
（4），一共要交换 3 次 = arr.length / 2
每次交换时，对应的下标时 arr[i] 和 arr[arr.length - 1 - i]
public class test1 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
int temp = 0;
int len = arr.length;
for(int i = 0; i < len / 2; i++)
{
temp = arr[len-1-i];
arr[len-1-i] = arr[i];
arr[i] = temp;
}
for(int i = 0; i < len; i++)
{
System.out.print(arr[i] + "\t");
}
}
}
运行结果：
167，数组反转2（使用逆序赋值方式）
思路：
（1），先创建一个新的数组 arr2，大小 arr.length
（2），逆序遍历 arr，将每个元素拷贝到 arr2 的元素中（顺序拷贝）
（3），建议增加一个循环变量 j，用来表示 arr2的元素下标
（4），当 for 循环结束，arr2 就是一个逆序的数组 {6,5,4,3,2,1}
（5），让 arr 指向 arr2 数据空间，此时 arr 原来的数据空间就没有变量引用，会被当做垃圾，销毁
public class test1 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
int[] arr2 = new int[arr.length];
for(int i = arr.length - 1, j = 0; i >= 0; i--, j++)
{
arr2[j] = arr[i];
}
arr = arr2;//引用赋值，见 163 节笔记
for(int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + "\t");
}
}
}
运行结果：
168，数组扩容1
1，实现动态的给数组添加元素效果，实现对数组扩容。
（1），原始数字使用静态分配 int[] arr = {1,2,3}
（2），增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
（3），用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
思路：
（1），定义初始数组 int[] arr = {1,2,3}
（2），定义一个新的数组 int[] arrNew = new int[arr.length+1];
（3），遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
（4），将 4 赋给 arrNew[arrNew.length - 1] = 4；把 4 赋给 arrNew 最后一个元素
（5），让 arr 指向 arrNew；arr = arrNew；那么，原来 arr 数组就被销毁
（6），创建一个 Scanner 可以接受用户输入
（7），因为用户什么时候退出，不确定，老师使用 do-while + break来控制
import java.util.Scanner;
public class test1 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
int[] arr = {1,2,3}; //初始数组
do {
int[] arrNew = new int[arr.length + 1];
for (int i = 0; i < arr.length; i++) {
arrNew[i] = arr[i];
}
System.out.println("请输入你要添加的元素");
int addNum = myScanner.nextInt();
arrNew[arrNew.length - 1] = addNum; //arrNew最后一个元素是下标为arrNew.length-1
arr = arrNew;
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println("是否继续添加 y/n");
char key = myScanner.next().charAt(0);
if(key == 'n') //如果输入n，就结束
{
break;
}
}while(true);
System.out.println("你退出了添加....");
}
}
运行结果：
170，数组缩减（仿照上个题的思路）
public class test1 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
int[] arr = {1,2,3,4,5}; //初始数组
do {
int[] arrNew = new int[arr.length-1];
for (int i = 0; i < arr.length-1; i++) {
arrNew[i] = arr[i];
}
arr = arrNew;
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println("是否继续缩减 y/n");
char key = myScanner.next().charAt(0);
if(key == 'n') //如果输入n，就结束
{
break;
}
if(arr.length == 1)
{
System.out.println("不能再缩减");
break;
}
}while(true);
System.out.println("你退出了缩减....");
}
}
运行结果：
172，冒泡排序
总结冒泡排序特点（看视频后就能理解了）：
1，我们一共有5个元素
2，一共进行了4轮排序，可以看成是外层循环
3，每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数，第2轮排序，确定第2大的数位置，依次类推
4，当进行比较时，如果前面的数大于后面的数，就交换
5，每轮比较在减少 4->3->2->1
public class test1 {
public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
int temp = 0; //用于辅助交换的变量
//将多轮排序使用外层循环包括起来即可
for(int i = 0; i < arr.length - 1; i++) //外层循环是4次
{
for(int j = 0; j < arr.length - 1 - i; j++)//4次比较->3次->2次->1次，每轮比较在减1
{
if(arr[j] > arr[j+1])//如果前面的数（大） > 后面的数（小），就交换。本来顺序是 大 小；要从小到大排序，顺序变为 小 大。要看清顺序
{ //如果是从大到小，只改成 < ,其余不变
temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
System.out.println("\n==第" + (i+1) + "轮==");
for(int j = 0; j < arr.length; j++)
{
System.out.print(arr[j] + "\t");
}
}
}
}
运行结果：
174，查找
1，顺序查找
有一个数列：白眉鹰王，金毛狮王，紫衫狮王，青翼蝠王，从键盘中任意输入一个名称，判断数列中是否包含此名称。要求：如果找到了，就提示找到，并给出下标值。
思路：
（1），定义一个字符串数组
（2），接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出
import java.util.Scanner;
public class test1 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
System.out.println("请输入名字");
String findName = myScanner.next();
int index = -1;
for(int i = 0; i < names.length; i++)//顺序遍历查找
{
if(findName.equals(names[i]))//字符串比较 equals，如果输入的名字和当前遍历的数组名字相同
{
System.out.println("恭喜你找到 " + findName);
System.out.println("下标为= " + i);
index = i; //也可以是其他值，除了设的-1
break;
}
}
if(index == -1) //如果没有找到，index 用来提示这种情况
{System.out.println("sorry，没有找到 " + findName);
}
}
}
运行结果：
175，二维数组入门
二维数组：1，从定义形式上看 int[][] ；
2，可以这样理解，二维数组的每个元素是一维数组，所以如果需要得到每个一维数组的值，还需要再次遍历
3，如果我们要访问第（i+1）个一维数组的第 j+1 个值 arr[i][j]，下标从0开始
4，第2个指向才是真正的存储空间
public class test1 {
public static void main(String[] args) {
int[][] arr = {{0,0,0,0,0,0},
{0,0,1,0,0,0},
{0,2,0,3,0,0},
{0,0,0,0,0,0}};
//二维数组是由4个一维数组构成的
System.out.println("二维数组的元素个数= " + arr.length); //输出是 4
System.out.println("第3个一维数组的第4个值= " + arr[2][3]);
for(int i = 0; i < arr.length; i++)//遍历二维数组的每个元素，相当于行
{
//arr[i] 表示二维数组的第 i+1 个元素，比如arr[0]:二维数组的第一个元素
//arr[i].length 得到对应的每个一维数组的长度
for(int j = 0; j < arr[i].length; j++)//相当于列
{
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}
运行结果：
181，杨辉三角
使用二维数组打印一个 10 行杨辉三角（图在网上搜的，可以便于理解杨辉三角的特点）
特点：1，第一行有1个元素，第n行有n个元素
2，每一行的第一个元素和最后一个元素都是1
3，从第三行开始，对于非第一个元素和最后一个元素的元素的值 arr[i][j] = arr[i-1][j] + arr[i-1][j-1]
public class test1 {
public static void main(String[] args) {
int[][] yangHui = new int[10][]; //要求了10行，列数不确定
for(int i = 0; i < yangHui.length; i++)//遍历yangHui的每个元素，即一维数组
{
yangHui[i] = new int[i+1];//给每个一维数组（行）开空间（一维数组又指向了另一个空间，空间可以放[i+1]个数据，如果没有给一维数组new，那么arr[i]就是null,没有任何指向
for(int j = 0; j < yangHui[i].length; j++)//遍历一维数组
{
if(j == 0 || j == yangHui[i].length - 1)//每一行的第一个元素和最后一个元素都是1
{
yangHui[i][j] = 1;
}
else //中间的元素
{
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//输出杨辉三角
for(int i = 0; i < yangHui.length; i++)
{
for(int j = 0; j < yangHui[i].length; j++)
{
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();
}
}
}
运行结果：
186，本章作业3
1，已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序，比如：[10,12,45,90]，添加23后，数组为 [10,12,23,45,90]
思路：本质数组扩容 + 定位
1，我们先确定 添加数应该插入到哪个索引
2，然后扩容
public class test1 {
public static void main(String[] args) {
int[] arr = {10,12,45,90};
int insertNum = 23;
int index = -1; //index 就是要插入的位置
//遍历 arr数组，如果发现 insertNum <= arr[i],说明 i 就是要插入的位置
//使用 index 保留 index = i;
//如果遍历完后，没有发现 insertNum <= arr[i]，说明 index = arr.length，即添加到 arr的最后
for(int i = 0; i < arr.length; i++)
{
if(insertNum <= arr[i])
{
index = i;//设置为要插入的位置下标
break;//找到位置后，就退出
}
}
if(index == -1)//判断index的值
{
index = arr.length;//说明还没有找到要插入的位置，就是插入的数比arr数组最后一个位置的元素大
}
//扩容，先创建一个新的数组，大小 arr.length+1，
// 准备将arr的元素拷贝到arrNew，并且要跳过index位置
int[] arrNew = new int[arr.length + 1];
for(int i = 0, j = 0; i < arrNew.length; i++)// i 控制arrNew的下标，j 用来控制arr数组的下标
{
if( i != index)//如果插入的位置和当前遍历的下标不相等的话，说明可以把arr的元素拷贝到arrNew
{
arrNew[i] = arr[j];
j++;//拷完后，就开始拷arr数组的下一个位置的元素
}
else //相等的话，这个位置就是要插入的数
{
arrNew[i] = insertNum;
}
}
arr = arrNew;//让arr指向arrNew，原来的数组，就成为垃圾，被销毁
System.out.println("======插入后，arr数组的元素情况======");
for(int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + "\t");
}
}
}
运行结果：
187，本章作业4
1，随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值，求最大值和最大值的下标，并查找里面是否有 8
public class test1{
public static void main(String[] args){
int[] arr = new int[10];
for(int i = 0; i < arr.length; i++)
{
arr[i] = (int)(Math.random() * 100) + 1; //这个死记住就行
}
System.out.println("====arr的元素情况=====");
for(int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + "\t");
}
System.out.println();
System.out.println("====arr的元素情况(倒序)=====");
for(int i = arr.length - 1; i >= 0; i--)
{
System.out.print(arr[i] + "\t");
}
//求最大值和最大值的下标，平均值
double sum = arr[0];
int max = arr[0];
int maxIndex = 0;
for(int i = 1; i < arr.length; i++) //i 从1开始的，就是从第2个元素开始的
{
sum += arr[i];
if(max < arr[i]) //求最大值
{
max = arr[i];
maxIndex = i;
}
}
System.out.println("\nmax= " + max + " maxIndex= " + maxIndex);
System.out.println("\n平均值= " + (sum / arr.length));
//顺序查找
int index = -1;
int findNum = 8;
for(int i = 0; i < arr.length; i++)
{
if(findNum == arr[i])
{
System.out.println("找到数" + findNum + " 下标= " + i);
index = i;
break;
}
}
if(index == -1)
{
System.out.println("没有找到数" + findNum);
}
}
}
运行结果：
