java_day8 - 《Java 笔记 - 反射动态代理》

作业，写一个计算器

数组

注意定义、创建以及赋值的步骤
定义和创建也可以合成一行： int[] nums = new int[10];

申明数组时，会进栈；创建的时候，数组会存进堆

数组初始化

稀里糊涂的，没搞懂为什么初始化以及为什么叫动态为什么叫静态

数组使用

package code_learn_day8;
public class Arry03 {
public static void main(String[] args) {
int[] arrays = new int[10];
for (int i = 0; i < 10; i++) {
arrays[i] = i;
}
for (int array : arrays){ // 增强型for循环
System.out.println(array);
}
int[] result = reverse(arrays); // 这里同样需要申明输出数组
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
} // 这里直接用for (int i : result) 会输出乱码，原因未知
}
// 反转数组
public static int[] reverse(int[] arrays) {
// 这里表示输入的是数组
int[] result = new int[arrays.length];
// 反转
for (int i = 0, j = result.length - 1; i < arrays.length; i++, j—) {
result[j] = arrays[i];
}
return result;
}
}

这是一个逆转数组并输出的程序，里面用到了数组、方法、数组调用以及方法调用，请注意注释

多维数组，相当于矩阵，提取按行和列的规则即可
多为数组用length指的是里面中括号的数量，二维数组就是行数
多维数组生成以及调用：

调用Arrays类中的sort和toString方法

冒泡排序
java跑完循环以后会清空大括号内新产生的变量，所以如果需要输出循环内新产生的变量，必须在循环前先定义好！

import java.util.Arrays;
public class Array07 {
public static void main(String[] args) {
int[] a = {679567, 4567, 456, 3, 2, 41, 24, 5, 23, 234, 45, 7, 4, 2345, 2, 34, 23, 4, 234, 23};
int temp = 0;
int i = 0;
for (i = 0; i < a.length - 1; i++) {
boolean flag = false; // 通过flag来减少没有意义的比较
for (int i1 = 0; i1 < a.length - i - 1; i1++) {
if (a[i1] > a[i1 + 1]) {
temp = a[i1 + 1];
a[i1 + 1] = a[i1];
a[i1] = temp;
flag = true;
}
}
if (flag == false) {
break;
}
}
System.out.println(Arrays.toString(a));
System.out.println(“循环了 “ + i + “次”);
// 冒泡排序
// 比较相邻数的大小，如果大小不对，则交换顺序，知道检测不到错的顺序
}
}

稀疏数组：

稀疏数组的生成与还原：

package code_learn_day8;
import java.util.Arrays;
public class SparseArray01 {
public static void main(String[] args) {
// 创建一个二维数组 11*11 0无棋子 1有棋子
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println(“输出原始数组”);
// 学习这里遍历整个数组的方法
for (int[] ints : array1) { // 相当于把array1里的数组赋值给新数组ints
for (int anInt : ints) { // 再把ints里的数赋值给anInt
System.out.print(anInt + “\t”);
}
System.out.println();
}
System.out.println(“==================================”);
// 转换为稀疏数组保存
// 获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int i1 = 0; i1 < 11; i1++) {
if (array1[i][i1] != 0){
sum++;
}
}
}
System.out.println(“有效值的个数：” + sum);
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.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[] ints : array2) {
for (int anInt : ints) {
System.out.print(anInt + “\t”);
}
System.out.println();
}
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) {
for (int anInt : ints) {
System.out.print(anInt + “\t”);
}
System.out.println();
}
}
}

注意java 从0开始的特点

面向对象编程OOP
以类的方式组织代码，以对象的组织封装数据
特点：封装、继承、多态

ended at No.59
to be continued…