Java学习#day06（数组的特点、定义格式、初始化方式，数组遍历，二维数组定义格式）

最新推荐文章于 2022-10-19 15:13:14 发布

我将以高达形态出击A_A

最新推荐文章于 2022-10-19 15:13:14 发布

阅读量576

点赞数 2

分类专栏：学习文章标签： java p2p 开发语言

本文链接：https://blog.csdn.net/Cinderella_996/article/details/122384700

版权

学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1、数组：存放同一种数据类型元素的集合，也可以看作是一个容器。
特点：
1、元素的数据类型一致，可以存放基本数据类型，也可以存放引用数据类型。
2、数组的长度是固定的。

数组的定义格式：
1、数据类型[] 数组名; （推荐使用第一种）
2、数据类型数组名[];

数组的初始化方式：
1、动态初始化：在定义时候只给定数组的长度，值是由系统默认给出的。
语句定义格式：数据类型[] 数组名 = new 数据类型[元素的个数];
举例：int[] arr = new int[3];
表示的是定义一个长度为3并且元素是int类型的一维数组。

2、静态初始化：在定义的时候，就手动给出元素值。
语句定义格式：数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2...};
简化格式：数据类型[] 数组名 = {元素值1,元素值2...};

JVM将内存划分成的5个部分，
栈：局部变量和方法的调用
堆：new出来的东西都在堆里面
方法区（面向对象的时候讲解）
本地方法区
寄存器

数组遍历：
获取的长度的属性：length
使用格式：数组名.length
======================================================================
/*
数组：
需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。
假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，
这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。
那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：
1、数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
2、数组既可以存储基本数据类型，也可以存储引用数据类型。

语句定义格式：
格式1：数据类型[] 数组名;
举例：int[] arr; 推荐第一种方式。
格式2：数据类型数组名[];
举例：int arr[] 定义一个存放int类型数据的数组。
为什么不推荐使用第二种方式。
从辨识度来看，第一种一眼就能识别是一个数组。
从使用长久来看，今后使用的趋势是第一种，第二种渐渐会被淘汰。

数组不初始化不能被使用，初始化？
初始化就是给这个变量开辟一个内存空间，为将来的值提供存放的空间

那么数组如何初始化呢？
两种：
1、动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
动态初始化的语句格式：
存放元素的数据类型[] 数组名 = new 存放元素的数据类型[数组的长度];
举例：定义一个可以存放3个int类型数据的数组。
int[] bigdata15 = new int[3];
2、静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
======================================================================
/*
通过前面的学习，我们学会了如何定义一个数组，以及如何初始化一个数组。但是我们获取元素输出的时候，发现元素的值是
系统给的，更多的时候，我们创建数组的目的是自己存放一些元素值。

如何给数组中的元素进行赋值呢？
通过数组中的索引给元素进行赋值
*/
public class ArrayDemo2 {
public static void main(String[] args) {
//定义一个数组并动态初始化
//定义一个存放int元素类型的数组，最多可以存放3个。
int[] arr = new int[3];
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

System.out.println("============================");
//手动赋值
//给数组中第一个元素进行赋值
arr[0] = 10;
//给数组中第二个元素进行赋值
arr[1] = 20;
//给数组中第三个元素进行赋值
arr[2] = 30;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

}
}
======================================================================
/*
定义两个数组并赋值输出数组名和元素值
*/
public class ArrayDemo3 {
public static void main(String[] args) {
//定义第一个数组
int[] arr1 = new int[3];
arr1[0] = 11;
arr1[1] = 22;
arr1[2] = 33;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println("============================================");
//定义第二个数组
int[] arr2 = new int[4];
arr2[0] = 100;
arr2[1] = 200;
arr2[2] = 300;
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);

}
}
======================================================================
/*
定义两个数组，先定义一个数组，赋值，输出。
然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
然后给第二个数组赋值，再次输出两个数组的名及元素。

*/
public class ArrayDemo4 {
public static void main(String[] args) {
//定义第一个数组
int[] arr1 = new int[3];
arr1[0] = 11;
arr1[1] = 22;
arr1[2] = 33;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);

//定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
int[] arr2 = arr1;
arr2[0] = 100;
arr2[1] = 200;
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
}
}
======================================================================
/*
一维数组的静态初始化：初始化时指定每个数组元素的初始值，由JVM决定数组长度。(JVM根据我们给的元素个数自动推断长度)
静态初始化的语句格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,元素4...};
举例：int[] arr = new int[]{11,22,33,44,55};
表示的是定义一个存放5个int类型元素的数组，元素分别是11,22,33,44,55
简化写法：
数据类型[] 数组名 = {元素1,元素2,元素3,元素4...};
举例：int[] arr = {100,200,300,400};
表示的是定义一个存放4个int类型元素的数组，元素分别是100,200,300,400

*/
public class ArrayDemo5 {
public static void main(String[] args) {
//定一个数组并静态初始化
int[] arr = {100,200,300,400};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

}
}
======================================================================
/*
数组中常见的错误：
1、ArrayIndexOutOfBoundsException: 5 数组索引越界异常
访问了不该访问的索引。

2、NullPointerException 空指针异常
*/
public class ArrayDemo6 {
public static void main(String[] args) {
//定义一个数组，静态初始化
int[] arr = {11,22,33,44,55};

System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
// System.out.println(arr[5]);

arr = null;
System.out.println(arr[0]);

}
}
======================================================================
/*
数组遍历(依次输出数组中的每一个元素)
*/
public class ArrayDemo7 {
public static void main(String[] args) {
//定义一个数组并动态初始化
// int[] arr = new int[3]{11,22,33};
//注意动态初始化不能与静态初始化混合使用！！
int[] arr = new int[8];
//手动获取每个元素并赋值
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
arr[3] = 44;
arr[4] = 55;
arr[5] = 66;
arr[6] = 77;
arr[7] = 88;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
// System.out.println(arr[8]);

System.out.println("=======用for循环改进========");
for(int i=0;i<=7;i++){
System.out.println(arr[i]);
}
System.out.println("=======用for循环改进2=======");
//由于上面的数组我们一眼就可以数清有多少个元素，所以在循环的时候，可以确定一个范围
//但是呢，真正的开发中，数组中的元素远远不止这么点，可能会有很多
//这时候我们再去数的话，不仅会数错，而且消耗大量时间
//那怎么办？我想要用for循环，就必须得确定一个范围
//如果有一个办法可以获取数组的长度就好了
//java中数组提供了一个属性供我们使用，可以获取数组的长度
//这个属性叫做：length
//使用格式：数组名.length
//当长度可以确定后，for循环的索引范围就能确定了：length-1
int[] arr2 = {100,20,3,132,4232,413,132,434241,3213,21,312,321,3,213,213,21,32,3,435,4,5,43,3245,3,4,342343,2,423,43,4,324,265,5,645};
// int length = arr2.length;
// System.out.println(length);
// [100,20,3....]
for(int i=0;i<arr2.length;i++){
if(i==0){
System.out.print("["+arr2[i]+",");
}else if(i==arr2.length-1){
System.out.print(arr2[i]+"]");
}else {
System.out.print(arr2[i]+",");
}
}

//\r\n是windows中的换行符
System.out.println("\r\n======将打印数组封装成一个方法==========");
printArray(arr2);

}

/**
* 定义遍历数组的方法
* 返回值类型：void
* 参数列表：int[] arr
*
*/
public static void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
if(i==0){
System.out.print("["+arr[i]+",");
}else if(i==arr.length-1){
System.out.print(arr[i]+"]");
}else {
System.out.print(arr[i]+",");
}
}
}
}
======================================================================
/*
数组获取最值(获取数组中的最大值最小值)
*/
public class ArrayDemo8 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
//思路：任意取一个值，假设它就是最大值
//然后拿着这个值与其余的值做比较，如果说遇到了比它还大的值，将该值作为临时最大值，当遍历完之后，获取到真正的最大值
//一般情况下，取第一个元素为最大值
int max = arr[0];

for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}

System.out.println("数组中最大值为：" + max);

System.out.println("==============用方法改进==============");
int maxNumber = getMaxNumber(arr); //0x001
System.out.println("数组中最大值为：" + maxNumber);

}
/**
* 定义一个获取数组最大值的方法
* 返回值类型：int
* 参数列表：int[] arr
*/
public static int getMaxNumber(int[] arr1){ //0x001
int max = arr1[0];

for (int i = 1; i < arr1.length; i++) {
if (arr1[i] > max) {
max = arr1[i];
}
}
return max;
}
}
======================================================================
/*
数组元素逆序 (就是把元素对调)
*/
public class ArrayDemo9 {
public static void main(String[] args) {
int[] arr = {43,31,123,1,21};//{43,31,123,1,21} ==> {21,1,123,32,43}
System.out.print("数组逆序之前：");
printArray(arr);

//将0索引位置的元素与length-1位置上的元素进行交换
//将1索引位置的元素与length-1-1位置上的元素进行交换
//直到length/2
int temp = arr[0];
arr[0] = arr[arr.length-1];
arr[arr.length-1] = temp;

int temp2 = arr[1];
arr[1] = arr[arr.length-1-1];
arr[arr.length-1-1] = temp2;

//调用方法遍历数组
System.out.print("\r\n数组逆序之后：");
printArray(arr);

System.out.println("\r\n==================用for循环改进实现数组逆序1：==================");
int[] niXuArray1 = niXu(arr);
printArray(niXuArray1);

// System.out.println("\r\n==================用for循环改进实现数组逆序2(创建新的数组)：==================");
// int[] niXuArray2 = niXu2(arr);
// printArray(niXuArray2);

System.out.println("\r\n==================用for循环改进实现数组逆序3(定义指针)：==================");
int[] niXuArray3 = niXu3(arr);
printArray(niXuArray3);

}

/**
* 定义方法实现数组的逆序(方法3)指针
* 返回值类型：int[]
* 参数列表：int[] array
*
*/
public static int[] niXu3(int[] array){
for(int start=0,end=array.length-1;start<=end;start++,end--){
int temp = array[start];
array[start] = array[end];
array[end] = temp;
}
return array;
}

/**
* 定义方法实现数组逆序(方法2)
* 返回值类型：int[]
* 参数列表：int[] array
*
* 这种方式不推荐：
* 1、由于创建了新的数组，开辟了新的堆内存空间，这样会造成内存资源浪费
* 2、题目本来的意思，在原数组上做逆序
*
*/
public static int[] niXu2(int[] array){
int[] arr2 = new int[array.length];
for(int i=array.length-1;i>=0;i--){
arr2[arr2.length-1-i] = array[i];
}
return arr2;
}

/**
* 实现数组逆序的方法(第一种方式实现)
* 返回值类型：int[]
* 参数列表：int[] array
*
*/
public static int[] niXu(int[] array){
for(int index=0;index<array.length/2;index++){
int temp = array[index];
array[index] = array[array.length-1-index];
array[array.length-1-index] = temp;
}
return array;
}

import java.util.Scanner;

public class ArrayDemo10 {
public static void main(String[] args) {
String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};

//创建键盘录入对象
Scanner sc = new Scanner(System.in);

boolean flag = true;

while (flag) {
System.out.println("请输入数据（1-7）:");
int number = sc.nextInt();
if (number >= 1 & number <= 7) {
System.out.println(week[number - 1]);
} else if (number == 0) {
flag = false;
} else {
System.out.println("输入的数据有误，请重新输入！");
}
}

}
}
======================================================================
/*
数组元素查找(查找指定元素第一次在数组中出现的索引)
举例：{12，32，12，43，53，32，100，12} 32在数组中第一次出现的索引为1
*/
import java.util.Scanner;
public class ArrayDemo11 {
public static void main(String[] args) {
//定义一个数组并静态初始化
int[] arr = {12,32,12,43,53,32,100,12};
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入你要查找的元素：");
int number = sc.nextInt();

for(int i=0;i<arr.length;i++){
if(arr[i]==number){
System.out.println(number+"2在数组中第一次出现的索引为"+i);
//正确做法是查找到对应元素后，应该结束整个循环
break;
}

if(i==arr.length-1 && arr[arr.length-1]!=number){
System.out.println("您要查找的元素"+number+"不在数组中！");
}
}

}
}
======================================================================

2、二维数组：元素是由一维数组组成的数组
定义格式一：
数据类型[][] 数组名 = new 数据类型[m][n];
m:表示的是有多少个一维数组
n:表示的一维数组的元素个数
举例：int[][] arr = new int[3][2];
表示的是定义一个有3个长度为2的一维数组组成的二维数组。

定义格式二：
数据类型[][] 数组名 = new 数据类型[m][];
m:表示的是有多少个一维数组
举例：int[][] arr = new int[4][];

定义格式三：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2,元素3...},...};
简化格式：数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2,元素3...},...};

注意：
1、以下几种写法也是二维数组
数据类型[] 数组名[];
数据类型数组名[][];
2、格式3不能与格式1、格式2混合使用。
错误格式：int[][] arr = new int[2][]{{1,2},{3,1,2}};

需要掌握二维数组的遍历方式,结合着一维数组遍历方式去看
======================================================================
/*
二维数组概述
我们数加科技的大数据班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个大数据班。
这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。
由此可见：其实二维数组其实就是一个元素为一维数组的数组。

二维数组的语句定义格式：
数据类型[][] 变量名 = new 数据类型[m][n]; (推荐这种写法)
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例：
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素

还有可能看到以下几个写法，它们也是正确的：
1、int[] arr[] = new int[3][2];
2、int arr[][] = new int[3][2];

*/
public class Array2Demo1 {
public static void main(String[] args) {
//定义一个二维数组，使用格式一做初始化
int[][] arr = new int[3][2];

System.out.println(arr); // [[I@4554617c
System.out.println(arr[0]); // [I@74a14482
System.out.println(arr[1]); // [I@1540e19d
System.out.println(arr[2]); // [I@677327b6

//想获取第一个一维数组中的第一个元素怎么办呢？
//首先，得获取第一个一维数组
// int[] array1 = arr[0];
// //然后通过索引获取第一个元素
// System.out.println(array1[0]);
System.out.println(arr[0][0]);
System.out.println(arr[0][1]); //获取二维数组中第一个一维数组中的第二个元素
//ArrayIndexOutOfBoundsException: 2
// System.out.println(arr[0][2]); //获取二维数组中第一个一维数组中的第二个元素

System.out.println(arr[1][0]); //获取二维数组中第二个一维数组中的第一个元素
System.out.println(arr[1][1]); //获取二维数组中第二个一维数组中的第二个元素

System.out.println(arr[2][0]); //获取二维数组中第三个一维数组中的第一个元素
System.out.println(arr[2][1]); //获取二维数组中第三个一维数组中的第二个元素

}
}
======================================================================
/*
二维数组第二种定义格式：
数据类型[][] 变量名 = new 数据类型[m][];
举例：int[][] arr = new int[3][];

*/
public class Array2Demo2 {
public static void main(String[] args) {
//定义二维数组的第二种格式
int[][] arr = new int[3][];
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

//给二维数组种第一个元素赋值一个一维数组
//赋值后的意义是：表示二维数组种第一个元素是一个长度为4的int类型的一维数组。
arr[0] = new int[4];
//赋值后的意义是：表示二维数组种第二个元素是一个长度为5的int类型的一维数组。
arr[1] = new int[5];
//赋值后的意义是：表示二维数组种第三个元素是一个长度为10的int类型的一维数组。
arr[2] = new int[10];
System.out.println(arr); //二维数组的地址值
System.out.println(arr[0]); //二维数组中第一个一维数组的地址值
System.out.println(arr[1]); //二维数组中第二个一维数组的地址值
System.out.println(arr[2]);//二维数组中第三个一维数组的地址值

}
}
======================================================================
/*
二维数组中第三种格式：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
举例：int[][] arr = new int[][]{{1,2},{3,4,5},{1,2,34,5}};
简化版格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：int[][] arr = {{1,2},{3,4,5},{1,2,34,5}};
表示的是：二维数组arr中有三个一维数组，分别是{1,2}，{3,4,5}，{1,2,34,5}

*/
public class Array2Demo3 {
public static void main(String[] args) {
//数组的第三种格式定义
int[][] arr = {{1,2},{3,4,5},{1,2,34,5}};
System.out.println(arr); //二维数组的地址值
System.out.println(arr[0]); //二维数组第一个一维数组的地址值
System.out.println(arr[1]);//二维数组第二个一维数组的地址值
System.out.println(arr[2]);//二维数组第三个一维数组的地址值

//获取二维数组中第一个一维数组的第一个元素
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);

//获取二维数组中第二个一维数组中所有元素
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
System.out.println(arr[1][2]);

//获取二维数组中第三个一维数组中所有元素
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println(arr[2][2]);
System.out.println(arr[2][3]);
// System.out.println(arr[2][4]);

}
}
======================================================================
/*
二维数组遍历

数加科技
十三期
小王,小李
十四期
小明,小刘,小张
十五期
小虎,小宇,小旺,小凯
十六期
小火,小杨,小爱,小周
*/
public class Array2Demo4 {
public static void main(String[] args) {
//定义一个二维数组表示是一个数加科技
String[][] shujia = {{"小王", "小李"}, {"小明", "小刘", "小张"}, {"小虎", "小宇", "小旺", "小凯"}, {"小火", "小杨", "小爱", "小周"}};

for (int i = 0; i < shujia.length; i++) {
// System.out.println(shujia[i]);
//外层循环遍历到的是每一个一维数组
//要想获取每个一维数组中的元素，再进行一次for循环遍历
System.out.println("第" + (i + 1) + "个数组：");
for (int j = 0; j < shujia[i].length; j++) {
// System.out.println(shujia[i][j]);
if (j == shujia[i].length - 1) {
System.out.print(shujia[i][j] + "]");
} else if (j == 0) {
System.out.print("[" + shujia[i][j] + ",");
} else {
System.out.print(shujia[i][j] + ",");
}
}
//每次内循环结束表示打印完一个一维数组，换行
System.out.println();

}

}
}
======================================================================

公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

*/
public class Array2Demo5 {
public static void main(String[] args) {
//定义一个二维数组表示是一个公司，每个季度相当于一个一维数组作为二维数组的元素传入
int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};

// int[][] arr = new int[2][]{{1,2},{3,1,2}};

//定义一个变量统计总销售额
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum = sum + arr[i][j];
}
}

System.out.println("该公司年销售额为：" + sum);

}
}