java笔记7 数组与存储结构

已于 2022-03-03 14:39:11 修改
阅读量905 收藏
点赞数
文章标签： java intellij-idea
于 2022-03-03 02:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55472894/article/details/123240578
版权
本文详细介绍了Java中的数组，包括定义、初始化、遍历、拷贝、多维数组和数组存储表格数据的方法。此外，还讲解了Comparable接口以及冒泡排序和二分查找这两种常见算法。通过对数组的操作，展示了如何在Java中有效地管理和操作数据。
摘要由CSDN通过智能技术生成

文章目录

七.数组和数据存储

学习目标：
在这里插入图片描述

1.数组定义

数组是相同类型数据的有序集合。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

数组的四个基本特点：

  1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
  2. 其元素的类型必须是相同类型，不允许出现混合类型。
  3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
  4. 数组变量属于引用类型，数组也是对象,数组中的元素相当于对象的属性！

2.创建数组初始化

数组的声明方式（以一维数组为例）

type[ ] arr_name; //方式一
type arr_name[ ]; //方式二

注：

  • 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM 才分配空间，这时才与长度有关。
  • 声明一个数组的时候并没有数组真正被创建。
  • 构造一个数组，必须指定长度。

【示例】创建基本类型一维数组

public class test01 {
    public static void main(String[] args) {
        int[] s;//声明数组；
        s=new int[10];//给数组分别配空间；
        for(int i=0;i<10;i++){
            s[i]=2*i+1;//给数组元素赋值；数组是对象。数组中的元素就是对象的属性
            System.out.println(s[i]);
        }
    }
}

在这里插入图片描述

【示例】创建引用类型一维数组

class Man{
    private int age;
    private int id;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void setId(int id) {
        this.id = id;
    }

    public Man(int id, int age) {
        super();
        this.age = age;
        this.id = id;

    }
}
public class test02 {
    public static void main(String[ ] args) {
        Man[ ] mans; //声明引用类型数组；
        mans = new Man[10]; //给引用类型数组分配空间；
        Man m1 = new Man(1,11);
        Man m2 = new Man(2,22);
        mans[0]=m1;//给引用类型数组元素赋值； 将地址赋给它
        mans[1]=m2;//给引用类型数组元素赋值； 将地址赋给它
        System.out.println(mans[0].getAge());
        System.out.println(mans[1]);
        System.out.println(m2);
    }
}

运行结果：

3.初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

1.静态初始化

除了用 new 关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int [ ] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[ ] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

2.动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[ ] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

3.数组的默认初始化

数组是对象，它的元素相当于对象的属性；每个元素也按照属性的方式被默认初始化。

int a2[ ] = new int[2]; // 默认值：0,0
boolean[ ] b = new boolean[2]; // 默认值：false,false
String[ ] s = new String[2]; // 默认值：null, null

4.数组常见操作

遍历与拷贝

  1. 遍历指的就是“通过循环遍历数组的所有元素”。

  2. 拷贝指的是将某个数组的内容拷贝到另一个数组中

    注：实质上，后面大家学容器的扩容就是“数组的拷贝”。

1.数组的遍历

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

【示例】使用循环初始化和遍历数组

public class test03 {
    public static void main(String[] args) {
        int[] a=new int[4];
        //初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i]=100*i;
        }
        //读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

执行结果：
在这里插入图片描述

for-each循环

for-each专门用于读取数组或容器中所有的元素。

【示例】使用增强 for 循环遍历数组

public class test03 {
    public static void main(String[] args) {
        int[] a=new int[4];
        //初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i]=100*i;
        }
        for(int t:a){
            System.out.println(t);
        }
    }
}

执行结果同上

public class Test03 {
	public static void main(String[ ] args) {
		String[ ] ss = { "aa", "bbb", "ccc", "ddd" };
		for (String temp : ss) {
			System.out.println(temp);
		} 
    }
}

执行结果：
在这里插入图片描述

注意：

  1. for-each增强for循环在遍历数组过程中，仅可以读取，不能修改数组中某元素的值；
  2. for-each仅适用于遍历，不涉及有关索引（下标）的操作。

2.数组的拷贝

System.arraycopy(object src,int srcpos,object dest,int destpos,int length)

该方法可以将src数组里的元素赋值给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

在这里插入图片描述

【示例】数组的拷贝

public class test04 {
    public static void main(String[] args) {
        String[] s={"阿里","尚学堂","京东","搜狐","网易"};
        String[] sBak=new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for(int i=0;i<sBak.length;i++){
            System.out.println(sBak[i]+"\t");
        }
    }
}

3.java.util.Arrays类

Arrays类包含了：排序、查找、填充、打印内容等常见的数组操作。

使用Arrays类的一些操作

import java.util.Arrays;

public class test05 {
    public static void main(String[] args) {
        //使用Arrays类输出数组中的元素
        int[] a={1,2};
        System.out.println(a); //打印数组引用的值；
        System.out.println(Arrays.toString(a));  //打印数组元素的值;
 // 注： 此处的Arrays.to.String()fan方法是Arrays类的静态方法，不是Object的toString()方法。
        System.out.println(" ");

        //使用Arrays类对数组元素进行排序
        int[] b={1,2,3,7,6,5,4};
        System.out.println(Arrays.toString(b));
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
        System.out.println(" ");

        //使用Arrays类实现二分法查找法
        int[] c={1,2,3,7,6,5,4,3,2,1};
        System.out.println(Arrays.toString(c));
        Arrays.sort(c);  //使用二分法查找，必须先对数组进行排序；
        System.out.println(Arrays.toString(c));
        //返回排序后新的索引位置，若未找到返回负数；
        System.out.println("该元素的索引："+Arrays.binarySearch(c,6));
        System.out.println(" ");

        //使用Arrays类对数组进行填充
        int[] d={1,5,4,2,3};
        System.out.println(Arrays.toString(d));
        Arrays.fill(d,2,4,100);  //将2到4索引的元素替换为100；（不包括4）
        System.out.println(Arrays.toString(d));
    }
}

输出结果：
在这里插入图片描述

4.多维数组

**多维数组可以看成以数组为元素的数组。**可以有二维、三维、甚至更多维数组，但是实际开发中用

的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都很少）。

在这里插入图片描述

【示例】二维数组的声明

import java.util.Arrays;
public class test06 {
    public static void main(String[] args) {
        //java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[][] a=new int[3][];
        a[0]=new int[2];
        a[1]=new int[4];
        a[2]=new int[3];
        //int a1[][]=new int[][4];//非法
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}

输出：
在这里插入图片描述

【示例】二维数组的静态初始化

public class test06 {
	public static void main(String[ ] args) {
		int[ ][ ] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
		System.out.println(a[2][3]);  //  7
	}
}

【示例】二维数组的动态初始化

import java.util.Arrays;
public class test06 {
	public static void main(String[ ] args) {
		int[ ][ ] a = new int[3][ ];
		// a[0] = {1,2,5}; //错误，没有声明类型就初始化
		a[0] = new int[ ] { 1, 2, 3, 4 };
		a[1] = new int[ ] { 2, 2 };
		a[2] = new int[ ] { 2, 2, 3, 4 };
		System.out.println(a[2][3]);
		System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
		System.out.println(Arrays.toString(a[2]));
	} 
}

输出结果：
在这里插入图片描述

5.数组存储表格数据

雇员表

ID姓名年龄职能入职日期
1001K18讲师2-14
1002Z19助教4-21
1003Y20班主任5-21

观察表格，发现每一行可以使用一个一维数组存储：

Object[ ] a1 = {1001,“高淇”,18,“讲师”,“2-14”};

Object[ ] a2 = {1002,“高小七”,19,“助教”,“10-10”};

Object[ ] a3 = {1003,“高小琴”,20,“班主任”,“5-5”};

注：此处基本数据类型”1001”，本质不是 Object 对象。JAVA 编译器会自动把基本数据类型“自动装箱”成包装类对象。

我们只需要再定义一个二维数组，将上面 3 个数组放入即可：

Object[ ][ ] emps = new Object[3][ ];

emps[0] = a1;

emps[1] = a2;

emps[2] = a3;

1.使用二维数组保存表格数据

import java.util.Arrays;
public class test07 {
    public static void main(String[] args) {
        Object[] a1={1001,"K",18,"讲师","2-14"};
        Object[] a2={1002,"Z",19,"助教","4-21"};
        Object[] a3={1003,"Y",20,"主任","5-21"};
        Object[][] emps=new Object[3][];
        emps[0]=a1;
        emps[1]=a2;
        emps[2]=a3;
        System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));

        System.out.println("===============");
        for(int i=0;i<emps.length;i++){
            for(int j=0;j<emps[i].length;j++){
                System.out.print(emps[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

输出结果：
在这里插入图片描述

2.使用 javabean 和一维数组保存表格信息

/**
 * 使用 javabean 和一维数组保存表格信息
 */
import java.util.Arrays;
public class test08{
    public static void main(String[] args) {
        Emp[] emps={
                new Emp(1001,"K",18,"讲师","2-14"),
                new Emp(1002,"Z",19,"助教","4-21"),
                new Emp(1003,"Y",20,"主任","5-21")
        };
        for(Emp e:emps){
            System.out.println(e);
        }
    }
}

class Emp{
    private int id;
    private String name;
    private int age;
    private String job;
    private String hiredate;

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", hiredate='" + hiredate + '\'' +
                '}';
    }

    public Emp(int id, String name, int age, String job, String hiredate) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.job = job;
        this.hiredate = hiredate;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getHiredate() {
        return hiredate;
    }

    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}

执行结果：

在这里插入图片描述

6.Comparable接口

多个对象做比较，就要有“比较规则”，然后实现排序。

事实上，java中排序算法的底层也依赖Comparable接口。

Comparable接口中只有一个方法：

public int compareTo(Object obj)   // obj为要比较的对象

方法中，将当前对象和obj这个对象进行比较难，如果大于返回1，等一百返回0，小于返回-1.（此处的 1 也可以是正整数，-1 也可以是负整数)。 compareTo 方法的代码也比较固定：

public int compareTo(Object o) {
	Man man = (Man) o;
	if (this.age < man.age) {
		return -1;
	}
	if (this.age > man.age) {
		return 1;
	}
	return 0;
}

【测试 Comparable 接口】使用 Arrays 类对数组元素进行排序二

/**
 * 测试Comparable 接口
 */
import java.util.Arrays;
public class test09 {
    public static void main(String[] args) {
        Man2[] msMans={new Man2(3,"a"),new Man2(60,"b"),new Man2(2,"c")};
        System.out.println(Arrays.toString(msMans));
        Arrays.sort(msMans);
        System.out.println(Arrays.toString(msMans));
    }
}

class Man2 implements Comparable{
    int age;
    int id;
    String name;

    public Man2(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }

    @Override
    public int compareTo(Object o) {
        Man2 man = (Man2) o;
        if (this.age < man.age) {
            return -1;
        }
        if (this.age > man.age) {
            return 1;
        }
        return 0;
    }
}

输出结果：
在这里插入图片描述

7.常见的算法

动画演示网站：https://visualgo.net/

1.冒泡排序算法

a.冒泡排序的基础算法

冒泡排序算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就

把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

在这里插入图片描述

【示例】冒泡排序的基础算法

/**
 * 测试冒泡排序基础算法
 */
import java.util.Arrays;
public class TestBuddleSort {
    public static void main(String[] args) {
        int[] values={3,1,6,8,9,0,7,4,5,2};
        bubbleSort(values);
        System.out.println(Arrays.toString(values));
    }

    public static void bubbleSort(int[] values){
        int temp;
        for(int i=0;i<values.length;i++){
            for(int j=0;j<values.length-1-i;j++){
                if (values[j] > values[j+1]){
                    temp=values[j];
                    values[j]=values[j+1];
                    values[j+1]=temp;
                }
            }
        }
    }
}

执行结果：
在这里插入图片描述

b.冒泡排序的优化算法

我们可以把上面的冒泡排序的算法优化一下，基于冒泡排序的以下特点：

  1. 整个数列分成两部分：前面是无序数列，后面是有序数列。
  2. 判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序，无需再进行后续趟数的比较了。此时可以中止比较。

在这里插入图片描述

【示例】冒泡排序的优化算法

/**
 * 冒泡排序的优化算法
 */
import java.util.Arrays;
public class TestBuddleSort2 {
    public static void main(String[] args) {
        int[] values={3,1,6,8,9,0,7,4,5,2};
        bubbleSort2(values);
        System.out.println(Arrays.toString(values));
    }

    public static void bubbleSort2(int[] values){
        int temp;

        for(int i=0;i<values.length;i++){
            //定义一个布尔类型的变量，标记数组是否已达到有序状态
            boolean flag=true;
            /*内层循环：每一趟循环都从数列的前两个元素开始比较，比较到无序
            数组的最后*/
            for(int j=0;j<values.length-1-i;j++){
                //如果前一个元素大于后一个元素，则交换两个元素的值；
                if(values[j]>values[j+1]){
                    temp=values[j];
                    values[j]=values[j+1];
                    values[j+1]=temp;
                    //本趟发生了交换，说明该数组在本趟处于无序状态，需要继续比较；
                    flag=false;
                }
            }
            //根据标记量的值判断是否有序，若有序，则退出；若无序，则继续循环
            if(flag){
                break;
            }
            System.out.println((i+1)+"趟排序："+Arrays.toString(values));
        }
    }
}

执行结果：
在这里插入图片描述

2.二分法查找

二分法检索（binary search）又称折半检索。

二分法检索的基本思想是设数组中的元素从小到大有序地存放在数组（array）中，首先将给定值 key 与数组中间位置上元素的关键码(key)比较，如果相等，则检索成功；否则，若 key 小，则在数组前半部分中继续进行二分法检索; 若 key 大，则在数组后半部分中继续进行二分法检索。

这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。二分法检索是一种效率较高的检索方法。

import java.util.Arrays;
public class TestBinarySearch {
	public static void main(String[ ] args) {
		int[ ] arr = { 30,20,50,10,80,9,7,12,100,40,8};
		int searchWord = 20; // 所要查找的数
		Arrays.sort(arr); //二分法查找之前，一定要对数组元素排序
		System.out.println(Arrays.toString(arr));
		System.out.println(searchWord+"元素的索引："+binarySearch(arr,searchWord));
}
	public static int binarySearch(int[ ] array, int value){
 		int low = 0;
 		int high = array.length - 1;
 		while(low <= high){
 			int middle = (low + high) / 2;
 			if(value == array[middle]){
 				return middle; //返回查询到的索引位置
 			}
			 if(value > array[middle]){
 				low = middle + 1;
 			}
 			if(value < array[middle]){
 				high = middle - 1;
			 }
 		}
 		return -1; //上面循环完毕，说明未找到，返回-1
 	} 
}

执行结果：
在这里插入图片描述

K-ZY_*
关注
Java-数据结构-数组
weixin_45532984的博客
08-05 802
数组是在程序设计中，把具有相同类型的若干元素按有序的形式组织起来的一种形式。数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素。 数组作为线性表的实现方式之一，数组中的元素在内存中是连续存储的，且每个元素占相同大小的内存。...............
Java学习笔记7 数组
Bug练习生的博客
10-20 503
数组 数组的概念： 数组是一组类型相同的数据的集合； 也就是说，数组中可以存储多个数据，但是这些数据的类型必须相同； 数组能够作为数据的容器使用，把多个数据集中存储； 存储在数组中的数据，都有相应的索引值，可以方便获取或修改； 当需要同时保存多个类型相同的变量并进行处理时，可以考虑用数组，例如：多个人的成绩、多个员工的薪资…… 数组的特点： Java的数组与类、接口、枚举、注解并列，是引用类型的一种； Java的数组长度一经确定不能改变； 例如：一个数组的长度是10，那
Java 数组在内存中的结构
weixin_33739646的博客
11-12 446
翻译人员: 铁锚 翻译时间: 2013年11月12日 原文链接: What does a Java array look like in memory? Java中的数组存储两类事物： 原始值(int,char,...),或者引用(对象指针). 当一个对象通过 new 创建,那么将在堆内存中分配一段空间,并且返回其引用(指针). 对于数组，也是同样的方式. 1. 一维数...
java 中数组存储结构讨论！
HuangHe201691的博客
11-04 559
数组的存储结构是采用线性序列。 public class ArrayDemo { public static void main(String [] args) { //1.定义数组 int[] numbers; //2.分配内存空间 numbers = new int[4]; //3.为
Java回顾-数组的内存结构/常用方法
萌萌虎的博客
06-23 338
内存结构可分为三部分： 栈：存放局部变量（例如方法内的变量）。 堆：存放new出来的结构，如类的对象、数组等等。 方法区：包括静态域、常量池等。 如下图代码所示，在 main() 方法内创建了两个一维数组：arr1、arr，其实就是两个指针变量。它们两个在栈中存储，分别指向数组第一个元素，也就是说它们存放的是地址值。 如果我给arr1重新new了一个数组，那堆中就会在新的地址(0x5566)上划分一块数据区域，arr1会指向这个新区域，而
java 数组的存储结构
食種之食物
01-13 1787
1、存储基本数据类型的数组结构 public class TestPrimitiveArray { public static void main(String[] args) { //1.定义数组 int[] numbers; //2.分配内存空间 numbers = new int[4]; //3.为数组
java关于数组（学习笔记）
12-21
当数组存储Java对象时，实际上存储的是对象的引用，即内存地址，而不是对象本身。因此，数组中不能直接存储Java对象，而是存储指向这些对象的引用。 Java数组的一个关键特性是它的长度在创建时就固定了，无法在程序...
Java学习笔记，数组初步
02-06
5. 数组存储表格数据 表格数据模型是计算机世界最普遍的模型，可以这么说，大家在互联网上看到的所有数据本质上都是“表格”，无非是表格之间互相套用。 6. 冒泡排序算法 冒泡排序是最常用的排序算法，在笔试中也...
Java基础学习笔记之数组详解
08-25
Java中的数组是一种特殊的对象，它能够存储同一类型的多个值。数组是Java中的基本概念，它在内存中占据连续的空间，可以看作是一组相关变量的集合。数组在Java中被视为引用数据类型，这意味着数组的引用（即地址）...
【黑马程序员 Java 笔记】数组
qq_54110690的博客
02-13 6704
目录 1、数组的定义 2、数组的初始化 1）动态初始化 2）静态初始化 3、访问 1）数组的访问 2）数组元素的访问 4、内存分配 1）栈内存 2）堆内存 5、数组操作的两个常见小问题 1）索引越界 2）空指针异常 6、数组常见操作 1）遍历 2）获取最值 1、数组的定义 1）int[] arr...
JDK1.9-数组原理内存图
逍遥云恋
11-27 431
2.1 内存概述 内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程 序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。 Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。 2.2 Java虚拟机的内存划分 为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。 JVM的内存划分...
java数组内存结构
lovelife110的博客
05-17 1010
译自：programcreek Java中的数组存储两种东西之一：要么是原始值(int, char, ...)，或是引用(即指针)。 当一个对象通过"new"创建时，将会在堆内存分配空间，并且返回一个引用。这对于数组也是一样的，因为数组是对象。 1.一维数组 int arr[] = new int[3]; int[] arr 只是长度为3的整型数组的引用。假设你创建一个长度为10的...
【Java】内存中的数组
Yong.Sunshine
10-01 310
在讲内存中的数组之前，我们了解一下内存，Java是怎么使用内存的呢？简单的介绍一下java的内存机制。在Java里面把内存划分成两种：一种是栈内存，另一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被其...
【java基础复习】java中的数组在内存中是如何存储的？
最新发布
m0_60511809的博客
09-06 923
而使用两块空间存储数组变量和数组内容，那么我们进行赋值时，只是对内容地址的赋值，也就是说，当我们执行arrA = arrB;时，实际上是将arrA指向了和arrB相同的内存位置，而arrA原来指向的{1, 2, 3}的内存空间由于不再被引用而可以进行垃圾回收。其中，堆用于存储对象的实例和数组，而栈用于存储局部变量和方法调用的信息。对于数组来说，实际的数据内容存储在堆内存中。，a就是内存中一块存储空间的名称，它的地址也就是这块存储空间的地址，比如是0x1112，a的值是100，也就是这块内存空间里的内容。
Java 数组在内存中的结构是怎样的？数组访问、遍历、复制、扩容、缩容如何编写代码？
网络技术联盟站
05-04 693
在Java中，数组是一种对象，可以用关键字new创建。Java数组可以是一维的，也可以是多维的，如二维数组、三维数组等。数据类型 [ ] 数组名 = new 数据类型 [ 数组长度 ];其中，数据类型表示数组中存储的元素的类型，数组名是数组的标识符，数组长度表示数组中元素的个数。
Java数据结构----数组
automation666的博客
04-24 1109
1、数组可以存放多个。数组也是一种数据类型，是引用类型。即：数数据组一组就是一组数据。2、可以通过.length得到数组的大小长度。
Java数据结构（3）- 数组
m0_54883970的博客
09-06 307
以前学习数组都是： 数据类型 变量名 = new 数据类型[长度]，固定了长度，固定了类型。如果我们需要存储的数据是不同类型的怎么办？而且存储的数据个数也是不固定的，这个怎么办？今天我们就来解决这个问题，如果来定义一个不固定数据类型，不固定长度的数组。//自定义的容器类//需要存储数据，所以我们需要定义一个数组在内部int[] arr;//定义一个构造方法,在创建容器对象的时候就给内部的数组赋值//自动创建一个数组对象，并且其长度为5}//定义一个size字段，来记录每次添加的元素。
数组内存结构图解
千锋教育
02-07 691
1. 简介Java的内存，可以分为栈、堆、方法区、本地方法区、程序寄存器等几个核心部分。这一块的内容，以后小千会专门编写文章进行介绍，对于初学者来说，这还不适合我们学习。但是我们现在要先对以下三个概念有所了解：栈：栈中可以存储基本类型的数据和引用类型的地址。特点: 先进后出，一般空间比较小，存取速度较快。堆：堆中可以存储引用类型的数据。特点: 空间比较大，存储速度相对较慢。方法区：方法区中可以存储字符串常量池、静态数据、代码和类的元数据。我们知道，
Java数据结构和算法-----数组
07-03 435
在Java中，数组是用来存放同一种数据类型的集合，注意只能存放同一种数据类型(Object类型数组除外)。①、数组的声明1数据类型 [] 数组名称 =new数据类型[数组长度];这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面，我们推荐放在数组名称的前面，这样看上去 数据类型 [] 表示的很明显是一个数组类型，而放在数组名称后面，则不是那么直观。1数据类型 [] 数组名称 = {数组元素1，数组元素2，......}
Java入门笔记：数组详解与内存理解
Java笔记渗透是针对基础学习者的教程，主要讲解了数组在Java编程中的基本概念和使用方法。首先，我们来看第三章——数组的遍历与定义。 1. 定义数组： Java提供了三种方式来定义数组： - 第一种是动态创建，使用`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值