JAVA学习笔记（13）{数组}

我是世界大好人

已于 2023-03-12 12:06:30 修改

阅读量824

点赞数 1

分类专栏： java学习文章标签：学习数据结构 java jvm 开发语言

于 2023-03-12 12:00:02 首次发布

本文链接：https://blog.csdn.net/suosijieniwo/article/details/129386556

版权

java学习专栏收录该内容

13 篇文章 1 订阅

订阅专栏

数组

数组指的是一种容器，可以用来存储同种数据类型的多个值。

建议把数组的存储类型和数据类型保持一致。

数组的静态初始化

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

但也可以将new 数据类型直接省略简写，代码依然可以运行。

练习：

1.定义数组存储5个学生的年龄，定义数组存储3个学生的姓名，定义数组存储4个学生的身高

public class 数组初试
{
    public static void main(String[] args)
    {
        int arr1[]={1,2,3,4,5};//定义数组存储5个学生的年龄
        String arr2[]={"张三","李四","王五"};//定义数组存储3个学生的姓名
        double arr3[]={181.1,171.2,160.5,150.9};//定义数组存储4个学生的身高
    }
}

这里应该联想到，既然数组能够存数值，那么怎么使用，存放它呢？

如果尝试打印arr1后会发现打印出来了"[I@7ef20235"这么一个不可名状的东西，其实这是一串地址，是在内存空间中的位置

数组的动态初始化

数组类型 数组名[]=new 数据类型[]

数组默认初始化值

数据类型	初始化值
整数	0
小数	0.0
字符	'/u0000'空格
布尔	false
引用数据类型	null

数组动态初始化和静态初始化的区别

动态初始化：手动指定数组的长度，由系统给出默认初始化值

适用于明确元素个数，不明确元素数值的情况

静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度

适用于明确元素数值，不明确元素个数的情况

数组的索引

索引就是数组的下标，假设有一个数组，里面存放着5个元素，那么第一个元素的索引就是0，第二个元素的索引就是1，第三个数字的索引就是2，以此类推，可以看出，索引的特点：从0开始，逐个+1增长，连续不间断。

public class 数组索引
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
        int suoyin=arr[0];
        System.out.println(suoyin);
    }
}

当然利用索引我们可以将数值存入数组中

public class 数组索引
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
        /*int suoyin=arr[0];
        System.out.println(suoyin);*/
        arr[0]=100;
        System.out.println(arr[0]);
    }
}

当然，一旦100覆盖了原本arr[0]的数值之后，arr[0]的1也就不存在了

数组的遍历

数组遍历：将数组中所有的内容取出来，取出来之后可以（打印，求和判断......）

public class 数组遍历
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
        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]);
    }
}

一个个打印效率实在太低，所以可以用循环改进代码

public class 数组遍历
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
//        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]);
        for(int i=0;i<=4;i++)
        {
            System.out.println(arr[i]);
        }
    }
}

但是这种方法，你需要事先知道，这个数组元素的个数，所以这并不是最优解

所以这里可以使用length来调查这个数组的长度

public class 数组遍历
{
    public static void main(String[] args)
    {
        System.out.println(arr.length);
    }
}

这里就会打印出arr的元素个数为5，所以与上面的for循环相结合就有了

public class 数组遍历
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
//        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]);
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }
    }
}

练习：

1.定义一个数组，存储1，2，3，4，5遍历数组得到每一个元素，求数组里面所有的数据和

public class 数组求和
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
        int num=0;
        for (int i = 0; i < arr.length; i++)
        {
            num+=arr[i];
        }
        System.out.println(num);
    }
}

2.定义一个数组，存储1，2，3，4，5，6，7，8，9，10遍历数组得到每一个元素，体哦那估计数组里面一共有多少个能被3整除的数字

public class 统计个数
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5,6,7,8,9,10};
        int num=0;
        for (int i = 0; i < arr.length; i++)
        {
            if(arr[i]%3==0)
            {
                num++;
            }
        }
        System.out.println("数组里一共有"+num+"个能被3整除的数字");
    }
}

3.定义一个数组，存储1，2，3，4，5，6，7，8，9，10遍历数组得到每一个元素，

要求：1，如果是奇数，则将当前数字扩大两倍

2，如果是偶数，则将当前数字变成二分之一

public class 变化数据
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++)
        {
            if(arr[i]%2==0)
            {
                arr[i]/=2;
            }
            else
            {
                arr[i]*=2;
            }
            System.out.println(arr[i]);
        }
    }
}

java内存分配

栈	堆	方法区	本地方法栈	寄存器
方法运行时使用的内存图	存储对象或者数组，new来创建的，都存储在堆内存	存储可以运行的class	JVM在使用操作系统功能的时候使用，和我们开发无关	给CPU使用，和我们开发无关

我们主要掌握：堆和栈

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行

程序的主入口（main）方法开始执行时会进栈，代码执行完毕会出栈

堆：new来创建的，都存储在堆内存

呢我出来的东西会在这块内存中开辟空间并产生地址，并且每一块小空间的地址值都不同

举例：

public static void main (String[]args)
{
  int a=10;
  int b=10;
  int c=a+b;
  sout(c);
}

这段代码没有使用到new关键字，所以没有使用到堆这个空间，只用到栈，逐行执行代码

public class test1 
{
    public class test
    {
        public static void main(String[] args)
        {
            int arr[]=new int[2];
            System.out.println(arr);
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            arr[0]=11;
            arr[1]=22;
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            System.out.println("-----------");
            int arr2[]={33,44,55};
            System.out.println(arr2);
            System.out.println(arr2[0]);
            System.out.println(arr2[1]);
            System.out.println(arr2[2]);
        }
    }
}

这里的代码中含有new关键字了，所以会使用栈和堆两种内存，main方法加载到栈内存中开始执行，在栈内存中定义了一个int型名字叫arr的数组，等号右边有关键字，所以是在堆内存中开辟了一个空间

练习：

1.已知数组元素为{33，5，22，44，55}请找出数组中最大值并打印在控制台

public class 找最大值
{
    public static void main(String[] args)
    {
        int arr[]={33,5,22,44,55};
        int max=33;
        for (int i = 0; i < arr.length; i++)
        {
            if(max<arr[i])
            {
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}

注意事项：max的初始值必须为数组中的值，而不能为0，因为如果数组中的值全为负数，那么种种情况下，max的初始值是最大值，但是初始值0并不在数组中，所以不能把初始值设置为0

2.生成10个1~100之间的随机数存入数组。求出所有数据和，求出所有数据平均数，统计有多少个数据比平均值小

import java.util.Random;
public class 遍历数组求和
{
    public static void main(String[] args)
    {
        int arr[]=new int[10];
        Random r=new Random();
        for (int i = 0; i < arr.length; i++)
        {
            int num=r.nextInt(100)+1;
            arr[i]=num;
            System.out.println(arr[i]);
        }
        int sum=0;
        for (int i = 0; i < arr.length; i++)
        {
            sum+=arr[i];
        }
        System.out.println("数组中所有数字的和为"+sum) ;
        int avg=0;
        avg=sum/10;
        int num=0;
        System.out.println("数字的平均数为"+avg);
        for (int i = 0; i < arr.length; i++)
        {
            if(arr[i]<avg)
            {
                num++;
            }
        }
        System.out.println("比平均数少的数字有"+num+"个");
    }
}

3.定义一个数组，存入1，2，3，4，5.按照要求交换索引对应的元素。交换前：1，2，3，4，5。交换后：5，2，3，4，1

public class 交换数组中的数据
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
        int num;
        num=arr[0];
        arr[0]=arr[4];
        arr[4]=num;
        for (int i = 0; i < arr.length; i++)
        {
            System.out.println(arr[i]);
        }
    }
}

同理整个数组进行倒序可以这么写

public class 交换数组中的数据
{
    public static void main(String[] args)
    {
//        int arr[]={1,2,3,4,5};
//        int num;
//        num=arr[0];
//        arr[0]=arr[4];
//        arr[4]=num;
//        for (int i = 0; i < arr.length; i++)
//        {
//            System.out.println(arr[i]);
//        }
        int arr[]={1,2,3,4,5};
        int num=0;
        for (int i=0,j=4; i <j; i++,j--)
        {
            num=arr[i];
            arr[i]=arr[j];
            arr[j]=num;
        }
        for (int i = 0; i < arr.length; i++)
        {
            System.out.printlnarr[i]);
        }
    }
}

4.定义一个数组，存入1~5.要求打乱数组中的所有数据的顺序。

import java.util.Random;
public class 随机打乱
{
    public static void main(String[] args)
    {
        int arr[]={1,2,3,4,5};
        int num;
        Random R=new Random();
        int r=R.nextInt(5);//这里可以把限制范围5改为arr。length这样就可以用在其他数组上
        for (int i = 0; i < arr.length; i++)
        {
            num=arr[i];
            arr[i]=arr[r];
            arr[r]=num;
        }
        for (int i = 0; i < arr.length; i++)
        {
            System.out.println(arr[i]);
        }
    }
}