韩顺平老师在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开始
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);
}
}
}
运行结果: