day07_java_数组
d 07 Java数组(p 51-p 59)
1.什么是数组？
数组就是一组数的集合。
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。
- 其中，每一个数据称之为一个数组元素，每个数组元素都可以通过对应的下标进行访问。
多个相同类型的数据使用多个相同类型的变量来记录是十分麻烦的，优先使用数组进行记录，再依靠下标取出。
2.数组的声明和创建
- 首先必须声明数组变量，才能在程序中使用数组。
dataType[] arrayRefVar; //首选的方法，是Java中的首选定义方式
dataType arrayRefVar[]; //效果相同，但不是首选的方法,C和C++是这样定义的
- Java使用new操作符来新建数组
- Java中定义一个东西的通式为：变量类型 变量名字 = 变量值;
//Java中定义一个东西的通式为：变量类型 变量名字 = 变量值;
dataType[] arrayRefVar = new dataType[arraySize];
//数组的元素是通过索引进行访问的，数组索引从0开始；使用 数组名.length获取数组长度
public class Demo01 {
public static void main(String[] args) {
int[] nums; //1.声明数组，尚未赋值(没有分配内存空间)
nums = new int[3]; //2.创建数组的大小(分配空间),不写的话那我存多少呢？
//声明和创建一起写 int[] nums = new int[3];
//否则记录这10个数字，需要使用10个变量，此时使用一个变量就可以保存10个
//此时分配了一个内存空间叫做nums，再在这基础上开辟多个空间...
// 用于存储多个相同类型的数据
//3.给数组中的元素赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
System.out.println(nums[2]);//不赋值的话，输出默认值
//计算所有数字之和
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum+=nums[i];
}
System.out.println("数组中元素总和为："+sum);
}
}
- 数组的四个基本特点：
- 数组的长度是确定的，一旦被创建，则其大小不可以改变。
- 数组中的元素类型必须相同，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于引用类型，数组也可以视为对象，数组中的元素相当于该对象的成员变量。数组本身就是对象，Java中对象是存在于堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
3.三种初始化及内存分析
1) Java内存分析
① 堆
- 存放new的对象和数组(数组本身也是一种对象)
- 可以被所有的线程共享，不会存放别的对象引用
② 栈
- 存放基本变量类型(包含该基本变量类型的具体数值)
- 引用对象的变量(会存放该引用在堆里的具体地址)
③ 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量
声明数组时，数组是不存在的；数组都是通过new操作符创建出来的，存放在堆中；真正赋具体的值是存放在栈中的。
2) 三种初始化状态
- 静态初始化：创建+初始化
int[] a = {1,2,3};
Man[] men = {new Man(1,1),new Man(2,2)};//给内存空间一个名字
- 动态初始化：包含默认初始化
int[] a = new int[2];//创建后空间中均为默认值，可以随时初始化
a[0] = 1;
a[1] = 2;
- 数组的默认初始化
数组是引用类型(除了8大基本类型外，都是引用类型)，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
4.下标越界及小结
5.数组的使用
- 普通for循环：取出值或者下标进行操作
数组通常和for循环结合在一起使用，尤其是搭配增强for循环(for-each)使用。下面是普通for循环：
public class Demo02 {
public static void main(String[] args) {
int[] arrays = {-1,-2,-3,5,7,8,94,35,666};
//输出数组中的所有元素
for (int i = 0; i < arrays.length; i++) {
System.out.println("数组中第"+(i+1)+"个元素为："+arrays[i]);
}
System.out.println("========================");
//输出所有数组中元素之和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum+=arrays[i];
}
System.out.println("数组中所有元素之和为："+sum);
System.out.println("========================");
//查找最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if(arrays[i]>max){
max = arrays[i];
}else{
max = arrays[0];
}
}
System.out.println("数组中的最大值为："+ max);
}
}
for循环中找值，循环体外进行输出，因为结果输出一次即可，不要进入循环体中，否则会多次输出。
-
For-Each循环：打印一些结果
int[] arrays = {1,2,3,4,5} //使用arrays.for自动生成，省去了数组的下标 for(int array : arrays){ //arrays是数组,array是数组中的元素 System.out.println(array);//适合打印输出，不便单独操作其中的元素 } -
数组作方法参数：对数组进行操作处理
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+"\t");
}
}
- 数组作返回值 ：修改数组形成一个新的数组，返回新的数组
//数组作为返回值——反转数组
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;
}
6.二维数组
多维数组可以看作是数组的数组（即嵌套），比如二维数组就是一个特殊的一维数组，其中每一个元素都是一个一维数组。
//二维数组
int a[][] = new int[2][5];//2行5列的数组
int[][] arrays = {{1,2},{3,4},{5,6}}//int[]时每个位置上是元素，现在是数组{},3行2列[3][2]
一维数组可以看作是线，二维是直角坐标系，三维是空间坐标系，去确定一个点时所需的维度在不断提升。但是数组和真实世界的维度还是有区别的，因为数组自身是可以量化处理，而真实世界的上升维度是有限的，在人的认知范围内。
public class twoDarray {
public static void main(String[] args) {
/*
* [4][2]
* 1,2 array[0]
* 3,4 array[1]
* 5,6 array[2]
* 7,8 array[3]
* */
int[][] array = {{1,2},{3,4},{5,6},{7,8}};
// System.out.println(array[0]);//此时返回的是一个数组对象 [I@1540e19d
printArray(array[0]);//数组之中嵌套数组
System.out.println();
//因为array[0]是一个数组对象，所以使用printArray方法是可以取出该数组中的所有元素的
System.out.println("二维数组中的某个元素为："+array[0][1]);//使用二维数组角标也可以取出元素
System.out.println(array.length);//最外层数组的维度4
System.out.println(array[0].length);//嵌套在内层的数组的维度2
}
//打印数组元素,将数组封装成方法的参数
public static void printArray(int[] arrays){
System.out.print("数组对象中的每个元素为：");
for (int i = 0; i < arrays.length; i++) {
System.out.print("数组中的第" + (i+1) + "个元素为" + arrays[i] + "\t");
}
}
}
- 一次性取出多维数组中的所有元素，使用for循环
平常使用中，二维数组足矣，Java中不会使用多维数组进行操作，因为Java是面向对象编程，后续遇到的东西都会变成对象进行处理。这里多维数组了解即可，不必深究。
public class twoArray {
public static void main(String[] args) {
int[][] array = {{1,2},{3,4},{5,6},{7,8},{9,10}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+"\t");
}
}
}
}
7. Arrays类讲解
- 数组的工具类 java.util.Arrays 由于数组对象本身并未提供什么方法可以调用，但API中提供了一个工具类Arrays，从而可以对数组对象进行一些基本操作。
- Arrays类中的方法使用的修饰符均为static，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用(注意：是不用不是不能)，作为静态类可以 . 出来很多方法使用。
- 具有以下常用功能
- 给数组赋值：使用fill方法
- 对数组排序：使用sort方法，按升序
- 比较数组：使用equals方法比较数组中元素的值是否相等
- 查找数组元素：使用binarySearch方法能对排序好的数组进行二分查找操作
public class array {
public static void main(String[] args) {
int[] a = {1,23,12,2,34,1,555,9};
System.out.println(a);
//[I@1540e19d 数组的返回值的是一个对象object，本质是一个hashcode
//打印数组元素，以字符串的形式打印出来
System.out.println(Arrays.toString(a));//toString方法打印数组
printArray(a);
System.out.println();
Arrays.sort(a);
System.out.println(Arrays.toString(a));//升序,常用排序方法有8种
}
//方法类也都开可以自己写
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]+", ");
}
}
}
}
8.冒泡排序
冒泡的代码有两层循环：外层冒泡轮数，里层依次比较，循环嵌套的时间复杂度为O(n2)。
/*冒泡排序
1、比较数组中，两个相邻的元素，如果前一个数字比后一个数字大，则交换位置
2、每一次比较都会产生一个最大或者最小的数字
3、下一轮可以减少一次排序顺序，同时参与排序的元素也会减少一个
4、依次循环，直至结束。
**/
public class test {
public static void main(String[] args) {
int[] a = {1,2,3,55,4,3,2,666,76,9};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array) {
int temp = 0;
boolean flag = true; //减少不必要的比较
//外层循环，判断走多少次循环
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;
flag = false;
}
}
if(flag){
break;
}
}
return array;
}
}
9.稀疏数组
稀疏数组属于一种数据结构，是一种压缩算法，用于压缩数组，便于保存，大大减少空间储存量。遍历后再进行取值和赋值的工作，稀疏数组——记录有效的坐标及其坐标值。
-
需求：编写五子棋游戏时，有存盘退出和续上盘的功能。因为该二维数组的很多值默认是0，因此记录了很多没有意义的数据；解决方法就是使用稀疏矩阵进行数据的记录。
-
当一个数组中大部分元素为0，或者为同一数值时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式：
- 记录数组有几行几列，有多少个不同值
- 记录的数据有：①几行几列 ②几处是非零值（有效的数字） ③非零值的坐标位置以及非零值的具体数值，从而缩小程序的规模。
-
//稀疏数组——记录有效的坐标及其坐标值
public class demo08 {
public static void main(String[] args) {
//1、创建一个二维数组 11*11 1：黑棋 2：白棋
int[][] a1 = new int[11][11];
a1[1][2] = 1;
a1[2][3] = 2;
//使用增强for循环，输出原始数组
//System.out.println("输出原始的数组为：" + Arrays.toString(a1[1]));
for (int[] ints : a1) {
for (int anInt : ints) {
System.out.print(anInt+" ");
}
System.out.println();
}
System.out.println("=====================");
//转换为稀疏数组——遍历后再进行取值和赋值的工作
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if(a1[i][j]!=0){
sum++;
}
}
}
System.out.println("有效值的个数为："+sum);
//2、创建一个代表稀疏数组的二维数组
int[][] a2 = new int[sum+1][3];//列数固定为3列，行数为有效值个数加1
a2[0][0] = 11;
a2[0][1] = 11;
a2[0][2] = sum;
//遍历二维数组，将非零的值放入稀疏数组中
int count = 0;
for (int i = 0; i < a1.length; i++) {
for (int j = 0; j < a1[i].length; j++) {
if(a1[i][j]!=0){
count++;
a2[count][0] = i;
a2[count][1] = j;
a2[count][2] = a1[i][j];
//将非零值的行列位置对应的原始坐标以及具体数值放在稀疏矩阵中
}
}
}
System.out.println("输出稀疏数组：");
for (int i = 0; i < a2.length; i++) {
System.out.println(a2[i][0]+"\t"
+a2[i][1]+"\t"
+a2[i][2]+"\t");
}
System.out.println("=====================");
//还原
System.out.println("稀疏数组还原为原始数组：");
//1、读取系数数组
int[][] a3 = new int[a2[0][0]][a2[0][1]];
//2、给其中的元素还原回原来的值
for (int i = 1; i < a2.length; i++) {//从1开始，第0行是头部信息，不需要读取
a3[a2[i][0]][a2[i][1]]=a2[i][2];
}
System.out.println("输出还原的数组：");
for (int[] ints : a3) {
for (int anInt : ints) {
System.out.print(anInt+" ");
}
System.out.println();
}
}
}
浙公网安备 33010602011771号