package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
// 需求：一堆分数，要统计最高分、最低分、总分、平均分
// int score1 = 80;
// int score2 = 70;
// int score3 = 90;
// int score4 = 65;
// // ...
// // 以计算平均分为例
// double average = ((double)(score1 + score2 + score3 + score4)) / 4;
// System.out.println("平均分为：" + average);
// 问题：相同意义的变量定义了一大堆，觉得这样一点都不简洁
// 思考解决方案：运用抽象的思维，类比生活中使用的冰格，作为一个制作冰块的容器，其内部每一个格子中的冰块可以单独使用的，兼具了批量性 和 独立性
// 那么考虑制作一个存放分数的容器，且在这个分数容器中的每一个分数也可以单独使用
// 数组：Array，存储同一数据类型的多个元素的容器
// 注意：【数组是引用数据类型（引用类型），基本数据类型是值类型】
// 内存：根据处理的内容的不同，分为 堆栈（栈：stack） 和 堆（Heap）
// 值类型：存储在栈中
// 引用数据类型：声明存储在栈中，内容存储在堆中
// 数组的格式：
// 形式1：数据类型[] 数组名（硬性要求：大家使用这种形式）：声明了一个xxx数据类型的数组，名字叫yyy
// 形式2：数据类型 数组名[]：声明了一个xxx数据类型，名字叫yyy的数组
// 声明一个成绩数组
// int[] scoreArr;
// int scoreArr[]; // 语法OK，但是不建议这样写
// 数组变量使用前必须进行初始化操作
// 语法错误：The local variable scoreArr may not have been initialized
// System.out.println(scoreArr);
// 数组初始化形式：
// 1、动态初始化：由使用者设置数组的长度，再填充元素
// 2、静态初始化：由使用者填充元素，由JDK计算数组的长度
// 动态初始化的格式：new 数据类型[数组的长度];
// A：new 关键字用来在内存的堆（Heap）中开辟一块空间
// B：数组的长度由使用者设置
// C：数组的下标（索引）用来表示数组中元素的位置，下标（索引）从0开始，到数组的长度-1结束
// 对于已经声明过的数组变量，进行动态初始化并赋值
// scoreArr = new int[3];
// 数组的初始化：可以把数组的声明 和 初始化 放在一行语句中执行
int[] scoreArr = new int[3];
// 下句输出 [I@15db9742 ，表示了scoreArr数组变量在内存中的类型 和 地址（以@符号作为分隔，前面是类型，后面是地址）
System.out.println(scoreArr); // [I@15db9742
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 数组的下标（索引）是从0开始的
// 数组的长度就是描述数组中元素的个数
// int[] arr = new int[3];
// arr[0] = 90; // 对数组中的第一个元素赋值为90
// 创建int类型的数组，向其中存放其他数据类型的元素，会发生什么现象？
// 向int类型的元素存放boolean类型的内容，语法出错
// 产生语法错误：Type mismatch: cannot convert from boolean to int
// arr[1] = true; // 对数组中的第二个元素赋值为true
// 向int类型的元素存放long类型的内容，语法出错
// 产生语法错误：Type mismatch: cannot convert from long to int
// arr[1] = 12345678901L;
// 向int类型的元素存放byte类型的内容，语法OK
// arr[1] = (byte)126;
// 向int类型的元素存放short类型的内容，语法OK
// arr[1] = (short)130;
// 【数组在内存中的存储形式】
// 赋值号左边的是数组的声明，类比名片
// 赋值号右边的是数组的内容，类比具体的家的位置
// 通过名片找到具体的家的位置
// 通过栈上声明的变量找到堆中具体存放内容的位置来使用数组
// System.out.println(arr); // [I@15db9742
// 数组中元素的默认值
// byte、short、int、long类型的数组的元素默认值为0
// int[] arr1 = new int[3];
// System.out.println(arr1[0]); // 0
// System.out.println(arr1[1]); // 0
// System.out.println(arr1[2]); // 0
// byte[] arr2 = new byte[3];
// System.out.println(arr2[0]); // 0
// System.out.println(arr2[1]); // 0
// System.out.println(arr2[2]); // 0
//
// short[] arr3 = new short[3];
// System.out.println(arr3[0]); // 0
// System.out.println(arr3[1]); // 0
// System.out.println(arr3[2]); // 0
//
// long[] arr4 = new long[3];
// System.out.println(arr4[0]); // 0
// System.out.println(arr4[1]); // 0
// System.out.println(arr4[2]); // 0
// double、float类型的数组的元素默认值为0.0
// double[] arr5 = new double[3];
// System.out.println(arr5[0]); // 0.0
// System.out.println(arr5[1]); // 0.0
// System.out.println(arr5[2]); // 0.0
//
// float[] arr6 = new float[3];
// System.out.println(arr6[0]); // 0.0
// System.out.println(arr6[1]); // 0.0
// System.out.println(arr6[2]); // 0.0
// char类型的数组的元素默认值为'\u0000'
// char[] arr7 = new char[3];
// System.out.println(arr7[0]); // '\u0000'
// System.out.println(arr7[1]); // '\u0000'
// System.out.println(arr7[2]); // '\u0000'
// boolean类型的数组的元素默认值为false
boolean[] arr8 = new boolean[3];
System.out.println(arr8[0]); // false
System.out.println(arr8[1]); // false
System.out.println(arr8[2]); // false
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
int[] scoreArr = new int[3];
System.out.println(scoreArr); // [I@15db9742
System.out.println(scoreArr[0]); //
System.out.println(scoreArr[1]); //
System.out.println(scoreArr[2]); //
System.out.println("-------------------------------------");
// 对数组中的部分元素进行赋值
scoreArr[0] = 80;
scoreArr[2] = 55;
// 1、数组的元素的值发生变化后，数组的地址没有变化
// 2、数组的元素的值发生变化后，数组中没有发生变化的元素的值还是之前的值
System.out.println(scoreArr); // [I@15db9742
System.out.println(scoreArr[0]); //
System.out.println(scoreArr[1]); //
System.out.println(scoreArr[2]); //
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// 需求：把数组中的元素的值都显示出来
int[] scoreArr = new int[3];
// 下面的写法可以实现需求，但是使用起来很不方便
// System.out.println(scoreArr[0]);
// System.out.println(scoreArr[1]);
// System.out.println(scoreArr[2]);
// 看到有重复的操作，就想到了循环
// for (int i = 0; i < 3; i++) {
// System.out.println(scoreArr[i]);
// }
// 上面的写法不具备通用性，因为这里的数字3是硬编码，其实它应该表示为数组的长度（数组中元素的个数）
// 通过使用 数组名.length 可以获取到数组的长度
// System.out.println("数组的长度为：" + scoreArr.length);
// 下面的写法就具备通用性（注意：eclipse中提供的for语句块结构：iterate over array，即在数组上进行迭代）
// for (int i = 0; i < scoreArr.length; i++) {
// System.out.println(scoreArr[i]);
// }
// 还有更加简单的写法，使用增强型for循环-----> foreach
// 增强型for循环的格式：for(数据类型 遍历变量名(迭代变量名) : 被遍历变量名(被迭代变量名)) { ... }
// for (int i : scoreArr) {
// System.out.println(i);
// }
// 注意：遍历变量名(迭代变量名)可以由使用者自己定义名称
// for (int item : scoreArr) {
// System.out.println(item);
// }
// 产生错误：Type mismatch: cannot convert from element type int to byte
// for (byte i : scoreArr) {
// System.out.println(i);
// }
// 产生错误：Type mismatch: cannot convert from element type int to short
// for (short i : scoreArr) {
// System.out.println(i);
// }
// 语法OK
// for (long i : scoreArr) {
// System.out.println(i);
// }
// 总结：被遍历的变量名的数据类型，认为其内部的元素也是该数据类型的，那么用范围比它大的数据类型接收时是可以的
// 用范围比它小的数据类型接收时就会抱语法错误
// 需求：使用循环和数组长度等技术点，制作一个方法printArray，用来打印数组中的元素，要求显示为[元素1的值, 元素2的值, ... 元素n的值]
printArray(scoreArr);
}
/**
* 打印数组方法
* @param arr：int类型的数组
*/
public static void printArray(int[] arr) {
// 最左边先打印出一个"["
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，加上"]"
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，加上","
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 10;
arr[1] = 21;
arr[2] = 30;
// 需求：制作一个方法getMaxItem，获取数组中的最大元素值
int maxItem = getMaxItem(arr);
System.out.println("数组中最大的元素为：" + maxItem);
// 需求：制作一个方法getMinItem，获取数组中的最小元素值
int minItem = getMinItem(arr);
System.out.println("数组中最小的元素为：" + minItem);
// 需求：制作一个方法getTotal，获取数组中的元素的总和
int total = getTotal(arr);
System.out.println("数组中元素的总和为：" + total);
// 需求：制作一个方法getAverage，获取数组中的元素的平均值
double average = getAverage(arr);
System.out.println("数组中元素的平均值为：" + average);
}
/**
* 获取数组中的最大元素值
* @param arr：数组
* @return：最大的元素值
*
* 思路：使用穷举思路
* 1、先设置一个作为比较的标杆，从数组中拿出一个元素认为它是最大的
* 2、把数组中的其他元素与之进行比较
* 3、如果有其他的元素比作为标杆的元素大，则替换之
* 4、比较完成后，就可以得到数组中的最大元素
*/
public static int getMaxItem(int[] arr) {
int tempMax = arr[0];
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] > tempMax) {
tempMax = arr[i];
}
}
return tempMax;
}
/**
* 获取数组中的最小元素值
* @param arr：数组
* @return：最小的元素值
*/
public static int getMinItem(int[] arr) {
int tempMin = arr[0];
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] < tempMin) {
tempMin = arr[i];
}
}
return tempMin;
}
/**
* 获取数组中的元素值的总和
* @param arr：数组
* @return：数组中元素的总和
*/
public static int getTotal(int[] arr) {
int total = 0;
// 遍历数组
for (int i = 0; i < arr.length; i++) {
total += arr[i];
}
return total;
}
/**
* 获取数组中的元素值的平均值
* @param arr：数组
* @return：数组中元素的平均值
*/
public static double getAverage(int[] arr) {
double total = 0.0;
for (int i = 0; i < arr.length; i++) {
total += arr[i];
}
return total / arr.length;
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 80;
arr1[2] = 55;
int[] arr2 = new int[3];
arr2[0] = 80;
arr2[2] = 55;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@6d06d69c
printArray(arr2);
System.out.println("----- 修改元素值 -----");
arr2[0] = 38;
arr2[1] = 100;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@6d06d69c
printArray(arr2);
// 不同的数组，元素的值相同，修改后，对其他数组中的元素的值无影响
// 因为不同的数组中的元素存放在内存的堆中不同的空间里
// 从运行的结果得知：
// 【只要使用了new关键字，就在内存的堆中开辟了新的空间】
}
/**
* 打印数组方法
* @param arr：int类型的数组
*/
public static void printArray(int[] arr) {
// 最左边先打印出一个"["
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，加上"]"
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，加上","
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 80;
arr1[2] = 55;
// 注意：下句语句体现了引用数据类型的特点
int[] arr2 = arr1;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@15db9742
printArray(arr2);
System.out.println("----- 修改元素值 -----");
arr2[0] = 38;
arr2[1] = 100;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@15db9742
printArray(arr2);
// 从运行的结果得知：
// 1、只要使用了new关键字，就在内存的堆中开辟了新的空间
// 2、引用数据类型在做值传递时，传递的是引用
}
/**
* 打印数组方法
* @param arr：int类型的数组
*/
public static void printArray(int[] arr) {
// 最左边先打印出一个"["
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，加上"]"
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，加上","
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// 值类型的特点
// int i = 2;
// int j = 2;
//
// System.out.println("i的值为：" + i);
// System.out.println("j的值为：" + j);
//
// System.out.println("----- 修改元素值 -----");
//
// j = 3;
//
// System.out.println("i的值为：" + i);
// System.out.println("j的值为：" + j);
int i = 2;
int j = i;
System.out.println("i的值为：" + i);
System.out.println("j的值为：" + j);
System.out.println("----- 修改元素值 -----");
j = 3;
System.out.println("i的值为：" + i);
System.out.println("j的值为：" + j);
// 值类型的特点
// 存储在栈上，没有栈和堆之间的指向引用，变化只影响自身
}
}
package cn.temptation;
public class Sample09 {
public static void main(String[] args) {
// 数组初始化
// 静态初始化：由使用者填充数组的元素，由JDK自动判定数组的长度
// 静态初始化的格式：
// 1、简写形式：{ 元素1, 元素2, ... 元素n}
// 2、完整形式：new 数据类型[] { 元素1, 元素2, ... 元素n}
// 简写形式
int[] arr1 = { 10, 20, 30 };
System.out.println("数组的长度为：" + arr1.length);
// 完整形式
int[] arr2 = new int[] { 10, 20, 30 };
System.out.println("数组的长度为：" + arr2.length);
// 遍历数组中的元素
// 方式1：一般for循环
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
// 方式2：增强型for循环
for (int item : arr2) {
System.out.println(item);
}
// 注意：
// 1、静态初始化的简写形式看起来没有new，但是实际上还是做了new的操作，还是在内存的堆上开辟了空间
// 2、数组的初始化有两种形式，使用时只能选择一种形式使用，不能混搭
// 混搭动态初始化和静态初始化会产生语法错误
// 产生语法错误：Cannot define dimension expressions when an array initializer is provided
// int[] arr3 = new int[3] { 10, 20, 30 };
}
}
package cn.temptation;
public class Sample10 {
public static void main(String[] args) {
// 1、下面语句是否在内存的堆中开辟了空间？ 答：new出了空间，地址为15db9742
// 2、下面这个数组长度是多少？ 答：数组长度为0
// 3、如何为这个数组填充元素并给元素赋值？
int[] arr = {};
System.out.println(arr); // [I@15db9742
System.out.println("数组的长度为：" + arr.length); // 0
// 遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int item : arr) {
System.out.println(item);
}
// 下句执行时会产生异常：java.lang.ArrayIndexOutOfBoundsException: 0，数组索引越界异常
// 因为当前arr数组中一个元素都没有，而下句语句要给第一个元素进行赋值，自然出现数组索引越界异常
// arr[0] = 10;
// 下句执行时会产生异常：java.lang.ArrayIndexOutOfBoundsException: 10，数组索引越界异常
// arr[10] = 99;
// 由上面的语句得知java.lang.ArrayIndexOutOfBoundsException后的数字指的是越界元素对应的索引
// 考虑1、考虑设置数组arr的length属性
// 语法错误：The final field array.length cannot be assigned
// 数组的length属性可以被读取，但是不可以被修改
// arr.length = 3;
// 考虑2、张冠李戴
// 通过创建一个新的数组，在堆中开辟一块新的空间，然后把指向之前开辟出的空间的引用（arr的栈堆之间的引用）改为指向新开辟的空间的引用
int[] arrExtend = { 10, 20, 30 };
arr = arrExtend;
// 遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int item : arr) {
System.out.println(item);
}
}
}