/*
- 数组
- 数组概念：是多个相同类型数据按照一定顺序排列的集合，并使用一个名字命名，并通过编号的方式
- 对这些数据进行统一管理
- 数组常见名词：数组名，角标或下标（索引），元素，数组的长度
- 数组特点，
- 1数组是有序排列的
- 2数组本身是引用数据类型，但数组中的元素可以使任何数据类型，包括基本数据类型和引用数据类型
- 3创建数组对象会在内存中开辟一整块连续的空间(不连续的如链表)，而数组名中引用的是这块连续空间的首地址
- 4数组的长度一旦确定，就无法更改
- 5可以直接通过下标的方式调用数组中指定位置的元素，速度很快
- 数组的分类
- 1，按照维度分一维数组二维数组，三维数组等
- 2，按照元素的数据类型分类，基本数据类型元素的数组，引用数据类型元素的数组（对象数组）
*一维数组的使用
*1，一维数组的声明和初始化方式
*2，如何调用数组指定位置的元素
*3，如何获取数组的长度
*4，如何遍历数组元素
*5，数组元素的默认初始化值
*6，内存中如何储存数组结构
*/
package com.atguigu.contact;
import java.util.*;
public class Array {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 一维数组的声明与初始化
int[] ids;// 声明数组 数组名称ids
ids = new int[] { 11, 12, 13, 14, 15, 16 };// 静态初始化方式：数组的初始化和数组元素的赋值操作同时进行
int[] array = new int[] { 1, 2, 3, 4, 5 };// 静态初始化方式可以写到一行里
//int array[] = new int[] { 1, 2, 3, 4, 5 };//声明变量名时中括号[]可以移动位置
//int arr[] = {1,2,3};//系统自动进行类型推断，这样写也可以，但尽量统一书写标准
//int arr1[];
//arr1 = {1,2,3,4};//因为分行写，无法自动推断类型，所以不能这样写
String[] names = new String[4];// 动态初始化：数组的初始化与数组元素的赋值分开操作，此处设置数组长度为4
// 错误方式 int[] arry = new int[];
// 错误方式 int[3] arry = new int[];
// 错误方式 int[] arry = new int[3]{1,2,3};
// 数组一旦完成初始化，则长度确定，内存空间分配好了。否则书写错误
// 调用数组指定位置的元素：通过角标的方式调用
// java中数组的角标从0开始，到数组的长度-1结束
// java中的角标一般都是从0开始，数据库的表从1开始
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";
names[3] = "马六"; // 对动态初始化的数组赋值
// names[4] = "周七";超出数组长度，可以编译但无法运行
System.out.println(names[2].charAt(0) + "的学号是" + ids[0] + "成绩为第" + array[1]);// 输出王的学号是11成绩为第2
// 获取数组的长度，通过数组的length属性 System.out.println(names.length);//输出4
// 遍历数组元素
// System.out.println(names[0]);//ctrl + shift + 下方向键可以复制当前行到下一行，但与Windows调整屏幕方向的快捷键冲突，可以自定义修改
// System.out.println(names[1]);
// System.out.println(names[2]);
// System.out.println(names[3]);//全选之后ctrl + /全部单行注释，再次ctrl + /取消注释
/*
* System.out.println(names[0]); System.out.println(names[1]);
* System.out.println(names[2]); System.out.println(names[3]);//全选之后ctrl + shift
* + /全部多行注释，ctrl + shift + \取消多行注释
*/
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);// 使用循环方式遍历数组
}
// java数组元素的默认初始化值
int[] array1 = new int[6];// 动态初始化数组array1
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);// 遍历array1，查询数组元素默认值
}
float[] array2 = new float[5];
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]);
}
char[] array3 = new char[5];
for (int i = 0; i < array3.length; i++) {
System.out.println("-" + array3[i] + "*");
}
if (array3[0] == '0') {
System.out.println("char类型数组元素的默认值是'0'");
} else {
System.out.println("char类型数组元素的默认值是0");
}
System.out.println('a');
System.out.println('a' + 0);
System.out.println('A' + 0);
System.out.println('0' + 0);
System.out.println(' ' + 0);
String[] array4 = new String[5];
for (int i = 0; i < array4.length; i++) {
System.out.println(array[i]);
}
if (array4[0] == "null") {
System.out.println("String类型数组元素的默认值是“null”");
} else {
System.out.println("String类型数组元素的默认值是null");
}
/*
* 如果默认元素是整型 ：0
* 如果默认元素是浮点型 ：0.0
* 如果默认元素是char型：0,或者说'\u0000'(unicode编码的0代表空字符)，而非'0'
* 如果默认元素是Boolean型 ：0(底层代码中0为false，1为true)
* 如果默认元素是引用数据类型例如String型 ：null(空值)
*/
// java数组的内存解析
/*
* 内存组成结构 栈（Stack）：储存局部变量（方法中定义的变量例如main方法） 堆（heap）：储存 对象，数组 方法区（method
* area）：方法区中包含常量池（String字符串）与静态域（static），还有其他信息
*/
// 一维数组的内存解析过程
int[] arr = new int[] { 1, 2, 3 };
// 在栈中创建一个变量名arr，在堆中创建一个连续的内存空间，长度3，有一个16进制的首地址值（例如0x122f）栈中的
// arr指向此地址值，堆中变量空间初始值为0，然后将大括号中的{1,2,3} 元素赋值到内存空间中
float[] arr1 = new float[4];
// 在栈中创建一个变量名arr1，在堆中创建一个连续的内存空间，长度为4，首地址值为（例如0x11ac），初始化值为0.0，栈中的arr1指向此地址值
arr1[1] = 2.1F;
// 赋值2.1到堆中arr1的第二个位置
arr1[2] = 3.2F;
// 赋值2.1到堆中arr1的第二个位置
arr1 = new float[5];
// 堆中新建一个连续空间，长度为5，首地址值为（例如0x24de），初始值为false，堆中的arr1重新指向新空间的首地址值
System.out.println(arr1[1]);// 输出0.0
/*
* 垃圾回收器通过引用技术算法判断堆空间的数组储存区域是否还有栈空间的变量名指向，没有则回收空间。 在main方法结束后，栈中的变量，与堆中的数组都会被回收
*/
// 数组练习1，输出电话号码
int[] arry2 = new int[] { 0, 1, 2, 5, 6, 7, 9 };
int[] index = new int[] { 1, 3, 2, 6, 5, 4, 6, 0, 2, 3, 5 };
String tel = " ";
for (int j = 0; j < index.length; j++) {
tel += arry2[index[j]];
}
System.out.println("联系方式" + tel);
//数组练习2从键盘输入学生成绩，找到最高分并且给成绩评定等级
System.out.println("请输入学生人数");
int studentNumber = scan.nextInt();
int[] score = new int[studentNumber];
int maxScore = 0;
for(int i = 0;i < studentNumber;i++){
System.out.println("请输入第" + (i + 1) + "名学生成绩");
score[i] = scan.nextInt();
if (score[i] >= maxScore) {
maxScore = score[i];
}
}
System.out.println("最高分为" + maxScore );
for (int i = 0; i < score.length; i++) {
switch ((maxScore - score[i] + 1) / 10) {
case 0:
System.out.println("学生" + (i + 1) +"成绩为" + score[i] + "等级为A");
break;
case 1:
System.out.println("学生" + (i + 1) +"成绩为" + score[i] + "等级为B");
break;
case 2:
System.out.println("学生" + (i + 1) +"成绩为" + score[i] + "等级为C");
break;
default:
System.out.println("学生" + (i + 1) +"成绩为" + score[i] + "等级为D");
break;
}
}
}
}
/*
- 多维数组
- 1.java语言里提供了支持多维数组的语法
- 2.如果说一维数组相当于线性图形，那么二维数组相当于一个Excel表格
- 3.二维数组可以看做是一个一维数组array1成为了另一个数组array2的元素
- 4.从数组底层的运行机制看，并没有多维数组，都右一维数组组成
- 二维数组的使用
*1，二维数组的声明和初始化方式
*2，如何调用数组指定位置的元素
*3，如何获取数组的长度
*4，如何遍历数组元素
*5，数组元素的默认初始化值
*6，内存中如何储存数组结构
*/
- 二维数组的使用
package com.atguigu.contact;
import java.util.*;
public class Array2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//二维数组的声明方式与初始化
int[][] array = new int[][] {{1,3,5},{0,2,4,6},{9,8,7,6},{0,0,0,0},{1,1}};//静态初始化方式
String[][] array1 = new String[3][4];//动态初始化方式一，相当于三行，每行两列，数组元素长度统一
boolean[][] array2 = new boolean[3][];//动态初始化方式二，可以不指定第二层数组的长度
//int[] array []= new int[][] {{1,3,5},{0,2,4,6},{9,8,7,6},{0,0,0,0},{1,1}};//与一维数组类似，声明变量名时中括号可以移动位置
//int array[][] = new int[][] {{1,3,5},{0,2,4,6},{9,8,7,6},{0,0,0,0},{1,1}};//与一维数组类似，声明变量名时中括号可以移动位置
//int array[][] = {{1,3,5},{0,2,4,6},{9,8,7,6},{0,0,0,0},{1,1}};//这样赋值也可以，但尽量统一书写方式
//调用二维数组指定位置的元素
System.out.println(array[0][1]);//输出3
System.out.println(array1[0][1]);//输出null
//System.out.println(array1[0][1]);//报错空指针异常，数组元素还没初始化
array2[0] = new boolean[] {false,false,true,true};//为array2的第一个数组元素赋值
System.out.println(array2[0][1]);//输出false
//获取二维数组的长度
System.out.println(array.length);//输出5
System.out.println(array[2].length);//输出4
//遍历二维数组元素,使用双重循环，三维数组需要三层循环
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
//二维数组元素的默认初始化值
/* 约定二维数组元素分为外层数组元素和内层数组元素
* 例如 int[][] arr = new int[4][3]; 动态初始化二维数组arr
* 外层元素指的是 arr[0],arr[1],...
* 内层元素指的是arr[0][0],arr[0][1],...
* 针对静态初始化方式，外层元素的初始化值为地址值，内层元素的初始化值与一维数组初始化情况相同
* 针对动态初始化方式，外层元素的初始化值为null，内层元素未初始化，不能调用，否则会报错
*/
int arr[][] = new int[4][3];
System.out.println(arr[0][0]);//输出0
System.out.println(arr[0]);//输出堆空间一维数组arr[0]的首地址值[I@1b6d3586，一个【代表一维数组，I代表Int类型
System.out.println(arr);//输出栈空间二维数组arr指向的首地址值[[I@4554617c，两个【【代表一维数组，I代表Int类型
float arr1[][] = new float[3][2];
System.out.println(arr1[0][1]);//0.0
System.out.println(arr1[0]);//一维数组地址值[F@74a14482
System.out.println(arr1);//二维数组地址值[[F@1540e19d
String arr2[][] = new String[3][2];
System.out.println(arr2[0][1]);//null
System.out.println(arr2[0]);//一维数组地址值[Ljava.lang.String;@677327b6
System.out.println(arr2);//二维数组地址值[[Ljava.lang.String;@14ae5a5
double arr3[][] = new double[3][];
//System.out.println(arr3[0][1]);//尚未初始化，报错
System.out.println(arr3[0]);//null，堆空间数组元素空间未开辟，没有地址值，此时为空值null，arr3 的元素为引用数据类型，默认值是null不是0.0
System.out.println(arr3);//[[D@7f31245a
//二维数组的内存解析
/*
* int arr[][] = new int[4][];
* 栈空间创建变量arr，赋值为堆空间一个一维外层数组的首地址，数组长度4.
* int arr[0] = new int[]{1,2,3,4};
* 堆空间创建一个内层一维数组arr[0],长度4，初始值0，后赋值4个元素。首地址值存入外层一维数组第一个位置
* int arr[1] = new int[3];
* 堆空间创建一个内层一维数组arr[1],长度3，初始值0。首地址值存入外层一维数组第二个位置
* int arr[1][1] = 1;
* 堆空间内层一维数组arr[1]第一个位置赋值为1
* int arr[1] = new int[5];
* 堆空间创建一个新的内层一维数组，长度5，首地址值存入外层一维数组arr第二个位置，
*/
}
}
