while 与 do while 的区别
do{
sum+=i;
i++;
}while(i<=100)
whlie 先判断，后执行
do while 先执行，后判断
do while 程序一定会执行一次，然后再进行条件的判断
for循环语句
增强for循环
int[] number = {10,20,30,40,50};
//遍历数组的元素---------------直接把number的值直接赋值给x，然后输出
for (int x:number){
System.out.println(x);
break与continue，goto
break 用于强行退出循环，不执行循环中剩余的语句，但程序尚未终止
continue 终止某次循环过程，跳过这一次循环，跳过循环体中尚未执行的语句，接下来直接判断下一次是否执行循环的判定，接着执行下一次循环。
goto
函数，方法
//修饰符 返回类型 方法名（参数类型 参数名）
public static void test(){
//方法体（具体的功能）
return 返回值； //当无返回值时，不需要return
}
实参与形参：
实参：调用方法的实体参数
形参：用来定义方法的参数
return：
一般返回语句return放在方法体的最下面
//return除了返回结果，还有终止方法的意思
-
方法返回一个值，方法调用通常被当作一个值
int larger = max(30,40);
-
方法返回值是void，方法调用一定是一条语句
System.out.println("Hello world!");
值传递与引用传递 （面试题）
java都是值传递
方法重载规则
-
方法名相同
-
参数列表不同
-
方法的返回值可以相同，可以不同
-
仅返回类型不同不能够成为方法的重载
命令行传参 （method Demo03）
当点击控制台下面的terminal 进入命令行
输入javac 包名.类名
或者 通过控制台进入命令行：
-
先通过文件位置 加cmd 进入控制台
-
javac 类名.java //编译
-
要回退到src目录才能执行:cd../ //因为包里面有个package，需要回退src，需要找到包的路径才能加载
-
java 包名.类名 + 传递的参数 //执行代码
可变参数/不定项参数（method Demo04）
-
指定参数类型后加一个省略号（...）
-
一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数都必须在的之前声明
递归（面试） （method Demo05）
-
递归头：什么时候不调用自己的方法，如果没有头，将陷入死循环。
递归中的f(1)
-
递归体：什么时候需要调用自身的方法。
method 练习：写一个计算器
数组
数组四个特征：
-
长度确定，一旦被创建，大小不可以改变
-
元素必须是相同类型的，不能够混合
-
元素可以是任何类型的，包括基本类型和引用类型
-
数组本身就是对象，数组的元素相当于对象的成员变量
数组的创建：（相关new的操作都会与堆有关）
int[] nums = new int[10]; //声明与创建
int[] nums; //1.声明一个数组 数组并不存在
nums = new int[10]; //2.创建一个数组 数组才会产生
int[] a = {1,2,3,4,5,6,7,8,9}; //静态初始化
array.length 数组的长度
-
静态初始化
创建＋赋值
-
动态初始化（数组一经分配空间，其中的每个元素都会被隐式初始化）
包含默认初始化---------int 默认初始化为0
一个错误BUG：
ArrayIndexOutOfBoundsException：数组下标越界了
数组的使用：
//反转数组------函数
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
//打印数组元素------函数
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
二维数组
int[][] array = {{1,2},{3,4},{5,6}};
printArray(array[0]);
System.out.println(array[0][0]);
System.out.println("-------------------------------------");
System.out.println(array.length); //输出的为二维数组的外层数组
System.out.println(array[0].length); //输出的为二位数字内层的数组
System.out.println("-------------------------------------");
for (int i = 0; i < array.length; i++) { //输出整个二维数组
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
System.out.println("-----------------------------");
}
}
}
int[] a = {1,2,34,5344,123,24,52};
System.out.println(a); //[I@7f31245a
Arrays.sort(a); //数组进行排序
System.out.println(Arrays.toString(a));
Arrays.fill(a,0); //数组填充(数组全都用0表示)
System.out.println(Arrays.toString(a));
}
//重新造轮子----------------------------------------定义打印数组函数
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if (i==0){
System.out.print("[");
}
if (i==a.length-1) {
System.out.print(a[i] + "]");
} else{
System.out.print(a[i]+",");
}
稀疏数组
| 行 | 列 | 值 |
|---|---|---|
| 11(棋盘总共多少行) | 11(棋盘总过多少列) | 3（总共棋盘中有三个非零的值） |
| 0 | 3 | 1 |
| 4 | 5 | 2 |
| 1 | 5 | 1 |
/*
array1 为最基础的矩阵
array2 为压缩的稀疏矩阵
array3 为稀疏矩阵返回的正常矩阵
*/
//1.创建一个二维数组11*11的棋盘 0：没有棋子 1：黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
System.out.println("输出原始数组：");
for (int[] ints : array1){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//转换为稀疏数组保存
//1.获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j]!=0) {
sum++;
}
}
}
System.out.println("有效值的个数:"+sum);
//2. 创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非零的值，存放在稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组：");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"+array2[i][2]+"\t");
}
//还原稀疏数组
//1. 读取稀疏数组
System.out.println("---------------------------");
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//给其中的元素还原值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//打印
System.out.println("输出还原数组：");
for (int[] ints : array3){ //遍历array3
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//冒泡排序
//比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们则交换他们的位置
//每一次标胶后都会产生一个最大或者最小的数字
//下一轮则可以少一次排序
//依次循环，直到结束
public static int[] sort(int[] array){
//临时变量
int temp = 0;
//外层循环。判断我们要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，如果第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j + 1] > array[j]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}