JavaSE----基础语法（数组）

1.9 数组

1.9.1 数组的概念

    概念:存储同一种数据类型的多个元素的容器。数组既可以存储基本数据类型，也可以存储引用数据类型

    格式：

    格式1：数据类型  []  数组名;

    格式2：数据类型  数组名  [];

    注意：这两种定义做完了，数组中是没有元素值的。如何对数组的元素进行初始化呢?

1.9.2 数组的初始化

   
数组初始化概述：Java中的数组必须先初始化,然后才能使用。所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

    数组的初始化方式：

    动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

    静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

    示例：

class ArrayDemo3{
public static void main(String [] args){
//动态初始化：
int[] arr = new int [3];//定义了一个数组长度为3的int类型数组。
//静态初始化：
int[] arr1 = new int[]{1,2,3};
}
}

1.9.3[b]数组的内存分配[/b]

    int[] arr = new int[4];

    内存分配图：



    Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

    内存的划分：

    栈内存：用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。

 
  堆内存：数组和对象，通过new建立的实例都存放在堆内存中。每个实例都有地址值，实例中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean类型是false，char类型是'\u0000'，引用类型是null。

 
  方法区：(面向对象部分详细讲解)。

 
  本地方法区：(系统相关)。

 
  寄存器：(CPU使用)。

 
  

1.9.4 [b]数组操作的练习[/b]

 
  练习1：数组遍历，就是依次输出数组的每一个元素

class ArrayTest{
public static void main(String[] args){
int[] arr = new int[]{11,22,33,44,55};
System.out.print("[");
for(int i = 0;i <= arr.length-1;i++){
if(i == arr.length-1){
System.out.print(arr[i]+"]");
}
else{
System.out.print(arr[i]+",");
}
}
}
}

    运行结果：



    练习2：数组获取最值(获取数组中的最大值最小值)

 
  思路：从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

class ArrayTest2{
public static void main(String[] args){
int[] arr = new int[]{1,34,55,66,23};
int max = getMax(arr);
System.out.println(max);
}
public static int getMax(int[] arr){
int max = arr[0];
for(int i = 1;i <= arr.length-1;i++){
max = (max>arr[i])?max:arr[i];
}
return max;
}
}

    运行结果：



    练习3：数组元素逆序 (就是把元素对调)

 
  方法1：

class ArrayTest3{
public static void main(String[] args){
//定义一个数组，并进行静态初始化。
int[] arr = new int[]{11,22,33,44,55};
System.out.print("逆序前:");
printArray(arr);
System.out.println();
System.out.print("逆序后:");
reverse(arr);
printArray(arr);
}
//逆序数组方法1：
public static void reverse(int[] arr){
for(int i = 0;i < arr.length/2;i++){
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
//遍历数组
public static void printArray(int[] arr){
System.out.print("[");
for(int i = 0;i <= arr.length-1;i++){
if(i == arr.length-1){
System.out.print(arr[i]+"]");
}
else{
System.out.print(arr[i]+",");
}
}
}
}

    运行结果：



    方法2：

class ArrayTest3{
public static void main(String[] args){
int[] arr = new int[]{11,22,33,44,55};
printArray(arr);
System.out.println();
reverse(arr);
printArray(arr);
}
public static void reverse(int[] arr){
int start = 0;
int end = arr.length-1;
while(start<=end){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
//遍历数组
public static void printArray(int[] arr){
System.out.print("[");
for(int i=0;i<=arr.length-1;i++){
if(i==arr.length-1){
System.out.print(arr[i]+"]");
}
else{
System.out.print(arr[i]+", ");
}
}
}
}

    运行结果：

[b]1.9.5 [b]数组操作的几个小问题[/b][/b]

    示例1：ArrayIndexOutOfBoundsException:数组索引越界异常

class ArrayDemo6{
public static void main(String [] args){
int[] arr = new int[]{1,2,3};
System.out.println(arr[3]);
}
}

    运行结果：



    示例2：

class ArrayDemo6{
public static void main(String [] args){
int[] arr = new int[]{1,2,3};
arr = null;
System.out.println(arr[0]);
}
}

    运行结果:

1.9.6 二维数组

    格式1：数据类型[][] 数组名 = new 数据类型[m]
;

    1、定义了名称为arr的二维数组。

   2、二维数组中有m个一维数组。

 
  3、每一个一维数组中有n个元素。

 
  4、一维数组的名称分别为arr[0], arr[1], arr[2]……arr[m-1]。

 
  5、给第一个一维数组第一个脚标位赋值为78写法是：arr[0][1] = 78;。

 
  6、arr存储的是二维数组的初始地址，arr[0]、arr[1]、arr[2]存储的是一维数组的初始地址。

 
  示例1：

class Array2Demo{
public static void main(String[] args){
int[][] arr = new int[3][2];
//打印二维数组的初始地址
System.out.println(arr);
//印二位数组中的角标为0的一维数组的地址。
System.out.println(arr[0]);
//打印二维数组中的角标为0的一维数组的角标为0的元素
System.out.println(arr[0][0]);
}
}

    运行结果：



 
  格式2：数据类型[][] 数组名 = new 数据类型[m][];

 
  二维数组中有m个一维数组，每个一维数组都是默认初始化值null，可以对这个m个一维数组分别进行初始化。

 
  示例1：

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[0][0]);
}
}

    运行结果：



    

 
  格式3：

 
  数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

    数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

 
  int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

 
  定义一个名称为arr的二维数组，二维数组中的有三个一维数组，每一个一维数组中具体元素也都已初始化。

    第一个一维数组 arr[0] = {3,8,2};，第二个一维数组 arr[1] = {2,7};，第三个一维数组 arr[2] = {9,0,1,6};。

    第三个一维数组的长度表示方式：arr[2].length;。

 
  示例1：

class Array2Demo3{
public static void main(String[] args){
int[][] arr = new int[][]{{3,8,2},{2},{9,4}};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

System.out.println(arr[0][1]);
System.out.println(arr[1][1]);
System.out.println(arr[2][1]);
}
}

    运行结果：



 
  二维数组的练习1：遍历二维数组

class Array2Test{
public static void main(String[] args){
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
printArray2(arr);
}
public static void printArray2(int[][] arr){
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}

    运行结果：



    二维数组练习2：公司年销售额求和

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

*/
class Array2Test2{
public static void main(String[] args){
int [][] arr = new int[][]{{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum = getSum(arr);
System.out.println(sum);

}

public static int getSum(int[][] arr){
int sum = 0;
for(int x=0;x<arr.length;x++){
for(int y=0;y<arr[x].length;y++){
sum+=arr[x][y];
}
}
return sum;
}
}

    运行结果：

思考题：

1、看程序，写结果：

/*
思考题1：看程序写结果，然后分析为什么是这个样子的。并画图讲解。最后总结Java中参数传递规律。
*/
class ArgsDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b); //a:??,b:??

int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //???
}

public static void change(int a,int b) {
System.out.println("a:"+a+",b:"+b); //a:10,b:20
a = b;	//a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a:20,b:40
}

public static void change(int[] arr) { //arr={1,2,3,4,5};
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}//int[] arr={1,4,3,8,5}
}
}

    运行结果：



    为什么会出来这样的结果呢？在Java中，基本类型的形式参数的改变对实际参数没有影响。引用类型的形式参数的改变直接影响实际参数。

 2、某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，然后，把加密后的结果在控制台打印出来。

class JiaMiDemo{
public static void main(String[] args){
//定义一个不大于8位数据
int number = 123456;
//定义一个数组
int[] arr = new int[8];
//定义一个索引
int index = 0;
//把数据中每一位上的数据获取到后存储到数组中
while(number>0){
arr[index]=number%10;
index++;
number/=10;
}
//每位数字都加上5，再用和除以10的余数代替该数字
for(int x = 0;x <index;x++){
arr[x]+=5;
arr[x]%=10;
}
//最后将第一位和最后一位数字交换
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = arr[0];

for(int x = 0;x<index;x++){
System.out.print(arr[x]);
}
}
}

    运行结果：



    将上面的代码改进一下：把数据改进为键盘录入，把代码改进为方法实现。

import java.util.Scanner;
class JiaMiDemo2{
public static void main(String[] args){
//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数据（小于8位）：");
int number = sc.nextInt();

String result = jiaMi(number);
System.out.println("加密后的结果："+result);
}
/*
写一个功能，把数据number实现加密。
两个明确：
返回值类型：String 做一个字符串的拼接
参数列表：int number
*/
public static String jiaMi(int number){
//定义数组
int[] arr = new int[8];
//定义索引
int index = 0;
//把number中的数据放到数组中
while(number>0){
arr[index]=number%10;
index++;
number/=10;
}
//把每个数据加5，对10取余数
for(int x = 0;x < index;x++){
arr[x]+=5;
arr[x]%=10;
}
//交换第一位和最后一位的数据
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;
//把数组的元素拼接成一个字符串返回
//定义一个空内容字符串
String s = "";
for(int x = 0; x < index;x++){
s+=arr[x];
}
return s;
}
}

    运行结果：



    经验证，正确。