【Java学习笔记】【数组】11.数组详解

已于 2022-04-12 14:05:22 修改
阅读量1.1k 收藏 1
点赞数 2
分类专栏： 【Java学习笔记】（不断更新） 文章标签： java
于 2022-04-12 00:14:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AmazingMing_/article/details/124113188
版权

数组

1.数组的定义与特点

数组的定义：

  • 数组是相同类型数据的有序集合；
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成；
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组的四个基本特点：

1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的；

2.其元素必须是相同类型，不允许出现混合类型；

3.数组中的元素可以是任何数据类型，包括基本类型和引用类型；

4.数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

2.数组的声明与创建

数组的声明：

首先要声明数组变量，才能在程序中使用变量，语法格式如下：

dataType[] arrayRefVar;  //首选的方法
或
dataType arrayRefVar[];  //效果相同，但不是首选方法

建议使用 dataType[] arrayRefVar;的方法声明数组变量，因为 dataType arrayRefVar[];的方式最初是为了让C/C++程序员能够快速理解Java语言。

举例：

int[] nums;   //声明了一个数组
或
int nums2[];

数组的创建：

语法格式如下：

arrayRefVar = new dataType[arraySize];

举例：

nums = new int[10];  //创建了一个数组

创建一个数组，赋值，并计算数组中所有元素的和：

public static void main(String args[]) {
    int[] nums;          //1.声明一个数组
    nums = new int[10];  //2.创建一个数组

    nums[0] = 1;         //3.给数组元素中赋值
    nums[1] = 2;
    nums[2] = 3;
    nums[3] = 4;
    nums[4] = 5;
    nums[5] = 6;
    nums[6] = 7;
    nums[7] = 8;
    nums[8] = 9;
    nums[9] = 10;
    //计算所有元素的总和
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {   //arrays.length获取数组长度
        sum = sum + nums[i];
    }
    System.out.println("总和为：" + sum);
}

3.内存分析

1.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度。例如：

int a[5];  //非法

2.声明一个数组的时候并没有数组被真正的创建。
3.构造一个数组，必须指定长度。

图解：

在这里插入图片描述

//1.声明一个数组
int[] myList = null;

在这里插入图片描述

//创建一个数组
myList = new int[10];

在这里插入图片描述

//3.向数组中赋值
myList[0] = 1;
myList[1] = 2;
myList[2] = 3;
myList[3] = 4;
myList[4] = 5;
myList[5] = 6;
myList[6] = 7;
myList[7] = 8;
myList[8] = 9;
myList[9] = 10;

4.三种初始化

静态初始化

除了用new关键字来创建数组以外，还可以直接在声明数组的同时为数组元素分配空间并赋值。

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

int[] a= new int[2];
a[0] = 1;
a[1] = 2;

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

举例：

public static void main(String args[]) {
    int[] a=new int[2];
    boolean[] b = new boolean[2];
    String[] s = new String[2];
    System.out.println(a[0]+":"+a[1]); //0,0
    System.out.println(b[0]+":"+b[1]); //false,false
    System.out.println(s[0]+":"+s[1]); //null, null
}

5.数组边界

下标的合法区间：[0,length - 1]，如果越界就会报错

int[] a=new int[2];
System.out.println(a[2]);
//报错
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
	at com.AmazingMing.struct.Demo01.main(Demo01.java:7)
//ArrayIndexOutOfBoundsException:数组下标越界异常

6.数组的应用

举例：数组的基本应用

public class Demo01 {
    public static void main(String args[]) {
        int[] arrays = {1,2,3,4,5};
        //1.打印数组中所有元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
        System.out.println();
        //2.计算数组中所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("sum=" + sum);
        //3.查找数组中最大元素
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if(arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("max=" + max);
    }
}
//输出结果：
1 2 3 4 5 
sum=15
max=5

For-Each循环

JDK1.5引进了一种新的循环类型，被称为For-Each循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下：

for(type element: array){
	System.out.print(element);
}
//IDEA快捷键：数组名.for

举例：

public static void main(String args[]) {
    int[] arrays = {1,2,3,4,5};
    for (int i : arrays) {
        System.out.println(i);
    }
}
//输出结果：
1
2
3
4
5

数组作方法参数

数组可以作为参数传递给方法。举例：

public static void main(String args[]) {
    int[] arrays = {1,2,3,4,5};
    printArray(arrays);    //调用printArray方法
}

public static void printArray(int[] arrays){  //定义printArray方法
    for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i] + " ");
    }
}

数组作返回值

举例：

public static int[] reverse(int[] arrays) {    //定义反转数组方法
    int[] result = new int[arrays.length];
    for (int i = 0, j = result.length-1;i < arrays.length; i++,j--) {  //i是从前往后，j是从后往前
        result[j] = arrays[i];
    }
    return result;
}

7.多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

多维数组的动态初始化(以二维数组为例)，直接为每一维分配空间，语法格式如下：

type[][] typename = new type[arrayLength1][arrayLength2];

type可以为基本数据类型和复合数据类型，arrayLength1和arrayLenght2必须为正整数，arrayLenght1为行数，arrayLenght2为列数。

举例：定义一个二维数组

int[][] a = new int[4][2];

理解二维数组

int [][] array = {{1,2},{2,3},{3,4},{4,5}};
//1,2  [0][0]  [0][1]
//2,3  [1][0]  [1][1]
//3,4  [2][0]  [2][1]
//4,5  [3][0]  [3][1]

举例：输出多维数组

public static void main(String args[]) {
    int [][] array = {{1,2},{2,3},{3,4},{4,5}};
    for (int i = 0; i < array.length; i++) {          //array.length为行最大值
        for (int j = 0; j < array[i].length; j++) {   //array[i].length为第一行中的最大值
            System.out.print(array[i][j] + " ");
        }
    }
}
//输出结果：
1 2 2 3 3 4 4 5

8.拓展：Arrays类

数组的工具类java.util.Arrays
API中提供了一个工具类Arrays供我们使用从而可以对数据对象进行一些基本的操作。

打印数组

public static void main(String[] args) {
    int [] a = {1,5,13,6511,15648,156,198869};
    System.out.println(a);
    System.out.println(Arrays.toString(a));
}
//输出结果：
[I@1b6d3586
[1, 5, 13, 6511, 15648, 156, 198869]

数组排序

public static void main(String[] args) {
    int [] a = {1,5,13,6511,15648,156,198869};
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));
}
//输出结果：
[1, 5, 13, 156, 6511, 15648, 198869]

数组赋值

public static void main(String[] args) {
    int [] a = new int[5];
    Arrays.fill(a,0);
    System.out.println(Arrays.toString(a));
}
//输出结果：
[0, 0, 0, 0, 0]

public static void main(String[] args) {
    int [] a = new int[5];
    Arrays.fill(a,2,4,1);         //第2到第4个数为1
    System.out.println(Arrays.toString(a));
}
//输出结果：
[0, 0, 1, 1, 0]

二分法查找

注意：使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行排序(通过sort方法等)。如果没有对数组进行排序，则结果是不确定的。

如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

public static void main(String[] args) {
    int[] a = {1, 5, 13, 6511, 15648, 156, 198869};
    Arrays.sort(a);            //使用二分法查找，必须先对数组进行排序
    System.out.println(Arrays.toString(a));
    System.out.println("该元素下标：" + Arrays.binarySearch(a, 13));
}

比较数组

public static void main(String[] args) {
    int[] a = {1, 5, 5, 10, 4, 2};
    int[] b = {1, 5, 5, 9, 4, 2};
    System.out.println(Arrays.equals(a, b));
}
//输出结果：
false

public static void main(String[] args) {
    int[] a = {1, 5, 5, 9, 4, 2};
    int[] b = {1, 5, 5, 9, 4, 2};
    System.out.println(Arrays.equals(a, b));
}
//输出结果：
true

9.冒泡排序

冒泡排序算法的原理如下：

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个；

2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，最后的元素应该会是最大的数；

3.针对所有的元素重复以上的步骤，除了最后一个；

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序时间复杂度为：O(n2)

举例：降序

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        int[] a = {2,14,3,7,6,10,4,8,13};
        int[] bubble = sort(a);
        System.out.println(Arrays.toString(bubble));
    }
    
    public static int[] sort(int[] array){
        int temp = 0;
        
        for (int i = 0; i < array.length - 1; i++) {           //外层循环，判断要走多少次
            int flag = 0;                                      //如果后方数组已经有序，可以退出循环
            for (int j = 0; j < array.length - i - 1; j++) {   //内层循环，判断是否交换位置
                if(array[j+1] > array[j]){                     //如果升序，将>改成<即可
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = 1;
                }
            }    
            if(flag == 0){
                break;
            }
        }
        return array;
    }
}
//输出结果：
[14, 13, 10, 8, 7, 6, 4, 3, 2]

10.选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到排序序列的末尾。以此类推，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

import java.util.Arrays;

public class Demo01 {
    public static int[] sort(int arr[]) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {           //修改最小值的下标
                    minIndex = j;
                }
            }                                           //此时已经找到最小值，需要交换位置
            if (i != minIndex) {                        //交换当前值和找到的最小值的位置
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = sort(array);
        System.out.println(Arrays.toString(sort));
    }
    /*
    public static void main(String[] args) {
        Demo01 selectSort = new Demo01();
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = selectSort.sort(array);
        for (int num : sort) {
            System.out.print(num + "\t");
        }
    }
    */
}
//输出结果：
[0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 8, 9]

11.稀疏数组

需求：编写五子棋游戏时，需要有存盘退出和继续游戏功能。

分析：因为该二维数组的默认值为0，因此记录了很多没有意义的数据。

稀疏数组解决：

记录数组一共几行几列，有多少个不同的值；把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模。

举例：

原始数组：

0  0  0  22  0  0  15
0  11  0  0  0  17  0
0  0  0  -6  0  0  0 
0  0  0  0  0  39  0
91  0  0  0  0  0  0
0  0  28  0  0  0  0

转化为稀疏数组：

行列值
[0][1][2]
[0]678
[1]0322
[2]0615
[3]1111
[4]1517
[5]23-6
[6]3539
[7]4091
[8]5228

第一行记录原始数组行数、列数和有效值的个数；

之后的每一行都记录原始数组中有效值的行数、列数和有效值大小。

例题：原始数组如下，用稀疏数组表示，并能将稀疏数组赚还原成原始数组：

0  0  0  0  0  0  0  0  0  0  0
0  0  1  0  0  0  0  0  0  0  0
0  0  0  2  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0  0  0  0

1.创建一个11*11的原始数组array1，0：没有棋子；1：黑棋；2：白棋

int[][] array1 = new int [11][11];

2.打印出原始数组

array1[1][2] = 1;                        
array1[2][3] = 2;
System.out.println("打印原始的数组：");
for (int[] ints : array1) {              //相当于把二维数组array1中所有一维数组都传给ints
	for (int anInt : ints) {             //相当于把一维数组所有元素都传给anInt，最后输出anInt即可
		System.out.print(anInt + "\t");
	}
	System.out.println();
}
//输出结果：
打印原始的数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0

3.获取有效值

int sum = 0;                             
for (int i = 0; i < 11; i++) {
	for (int j = 0; j < 11; j++) {
		if(array1[i][j] != 0){
			sum++;
        }
    }
}
System.out.println("有效值的个数：" + sum);
//输出结果：
有效值的个数：2

4.给稀疏数组array2赋值

int[][] array2 = new int[sum + 1][3];         
array2[0][0] = 11;                            //[0][0]位置存放稀疏数组的行数
array2[0][1] = 11;                            //[0][1]位置存放稀疏数组的列数
array2[0][2] = sum;                           //[0][2]位置存放有效值的个数
int count = 0;
for (int i = 0; i < array1.length; i++) {
	for (int j = 0; j < array1[i].length; j++) {
		if(array1[i][j] != 0){               //如果不是0，证明是有效值，存入array2
        	count++;                         //count表示稀疏数组中的行数
            array2[count][0] = i;
            array2[count][1] = j;
            array2[count][2] = array1[i][j];
		}
	}
}

5.打印稀疏数组array2

System.out.println("稀疏数组：");               
	for (int i = 0; i < array2.length; i++) {
		System.out.println(array2[i][0] + "\t" +
		array2[i][1] + "\t" +
	array2[i][2] + "\t");
	}
//输出结果：
稀疏数组：
11	11	2	
1	2	1	
2	3	2

6.还原原始数组

int[][] array3 = new int[ array2[0][0] ][ array2[0][1] ];  
for (int i = 1; i < array2.length; i++) {
	array3[ array2[i][0] ][ array2[i][1] ] = array2[i][2];
}
System.out.println("还原的原始数组：");
for (int[] ints : array3) {
	for (int anInt : ints) {
		System.out.print(anInt + "\t");
    }
    System.out.println();
}
//输出结果：
还原的原始数组：
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0

稀疏数组总程序：

public class Demo01 {
    public static void main(String[] args) {
        int[][] array1 = new int [11][11];       //1.创建一个11*11的原始数组array1，0：没有棋子；1：黑棋；2：白棋

        array1[1][2] = 1;                        //2.打印出原始数组
        array1[2][3] = 2;
        System.out.println("打印原始的数组：");
        for (int[] ints : array1) {              //相当于把二维数组array1中所有一维数组都传给ints
            for (int anInt : ints) {             //相当于把一维数组所有元素都传给anInt，最后输出anInt即可
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("======================================");
        int sum = 0;                             //3.获取有效值的个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" + sum);

        int[][] array2 = new int[sum + 1][3];                           //4.赋值稀疏数组array2
        array2[0][0] = 11;                                              //[0][0]位置存放稀疏数组的行数
        array2[0][1] = 11;                                              //[0][1]位置存放稀疏数组的列数
        array2[0][2] = sum;                                             //[0][2]位置存放有效值的个数
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j] != 0){               //如果不是0，证明是有效值，存入array2
                    count++;                         //count表示稀疏数组中的行数
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("======================================");
        System.out.println("稀疏数组：");                               //5.打印稀疏数组array2
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" +
                    array2[i][1] + "\t" +
                    array2[i][2] + "\t");
        }

        System.out.println("======================================");
        int[][] array3 = new int[ array2[0][0] ][ array2[0][1] ];      //6.还原原始数组
        for (int i = 1; i < array2.length; i++) {
            array3[ array2[i][0] ][ array2[i][1] ] = array2[i][2];
        }
        System.out.println("还原的原始数组：");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}
AmazingMing_
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java11----数组排序
weixin_45686974的博客
10-31 185
java11----数组排序 数组排序：把数组中得元素，通过比较移位替换，使之变成一个有序序列 排序方式：冒泡排序，选择排序，插入排序，希尔排序，快速排序，基数排序，堆排序，归并排序。 冒泡排序 冒泡排序：数组元素 两两比较，大的往后放，经过一轮比较后，最大得元素会出现在最后面，如此往复，那么整个数组元素就有序了。 代码演示： int[] arr = {24, 69, 80, 57, 1...
JAVA基础11——数组
想飞的鱼的博客
02-09 93
数组是一种数据结构，用来存储同一类型的集合。 一、数组的声明： 1. 类型名称[] 变量名=new 类型名称[length]; 2.类型名称[] 变量名={?,?,?}; 3.类型名称[] 变量名=new 类型名称[]{?,?,?}; public static void main(String[] args) { int[] arr = new int[3]; int[] brr = {1,2,3}; int[] crr = new int[]{1,2,3}; } 三种数组声明
java11：数组试用
浪漫的偷笑
10-01 111
package day11; import java.util.Arrays; public class Demo01 { public static void main(String[] args) { String[] names = {"张三","李四","王五","赵六","孙八"}; //数组转字符串 System.out.println(Arrays.toSt...
corejava11（3.10 数组）
nbda1121440的专栏
05-15 207
3.10 数组 数组保存同一类型的值序列。在下面的部分中，您将看到如何在Java中使用数组。 3.10.1 声明数组 数组是存储同一类型值集合的数据结构。您可以通过一个整数索引访问每个单独的值。例如，如果a是整数数组，则[i]是数组中的第i个整数。 通过指定数组类型来声明数组变量，该数组类型是元素类型后跟[]-和数组变量名。例如，下面是整数数组a的声明： int[] a; 但是，此语句只声明变量...
Java基础学习笔记之数组详解
08-25
Java中的数组是一种特殊的对象，它能够存储同一类型的多个值。数组是Java中的基本概念，它在内存中占据连续的空间，可以看作是一组相关变量的集合。数组在Java中被视为引用数据类型，这意味着数组的引用（即地址）...
Java数组的特性_动力节点Java学院整理
08-30
Java中的数组特性详解 在Java编程语言中，数组是一种特殊的数据结构，用于存储同类型的数据集合。尽管在C和C++等语言中，数组的概念相对简单直接，但在Java中，数组具有独特的特性和行为，这使得它们在某些方面与...
Java学习笔记整理
05-21
2. **Day728_ArrayList详解.docx**：ArrayList是Java集合框架中的动态数组，允许元素的动态添加和删除。文件可能详细解析了ArrayList的内部实现，包括其增长机制（当容量不足时如何自动扩容），以及如何通过索引访问...
Java开发详解.zip
09-02
000000_【课程介绍 —— 写在前面的话】_Java学习概述笔记.pdf 010101_【第1章：JAVA概述及开发环境搭建】_JAVA发展概述笔记.pdf 010102_【第1章：JAVA概述及开发环境搭建】_Java开发环境搭建笔记.pdf 010201_【第2...
java学习笔记之DBUtils工具包详解
08-28
Java学习笔记之DBUtils工具包详解 DBUtils是Apache组织开源的数据库工具类，提供了简洁的数据库操作方式，主要包括QueryRunner和ResultSetHandler两个主要组件。下面将详细介绍DBUtils工具包的使用步骤、构造方法及...
java 中的数组的试用_java11：数组试用
weixin_30387635的博客
03-01 70
packageday11;importjava.util.Arrays;publicclassDemo01{publicstaticvoidmain(String[]args){String[]names={"张三","李四","王五","赵六","孙八"};//数组转字符串System.out.println(Arrays.toString(names));for(in...
java 一维数组_11java的一维数组
weixin_34665982的博客
02-19 97
一维数组数组初始化的三种方式数组的默认初始化​ 数组是引用类型(除了八大基本数据类型，都是引用类型)，他的元素相当于类的实例变量。其中每个元素也按照实例变量的方式倍隐式初始化。静态初始化int[] array={1,2,3};Man[] mans={new Man(1,1),new Man(2,2)};//这是引用类型动态初始化int[] array=new int[10];arra...
Java数组所有元素之和
weixin_46429649的博客
10-29 807
public static int sum(int[] arr) { //实现一个方法 sum, 以数组为参数, 求数组所有元素之和. int sum = 0; for (int value : arr) { sum += value; } return sum; } public static void main(String[] args) { int[] arr = {1,2,3}; System.out.println(sum
java数组取三个数求和：
Zxdwr520的博客
07-04 1847
Java实现从数组内取三个数相加=100|1000
数组
Strive_to_become的博客
12-14 387
数组：存储一组相同数据类型的有序集合。 特点： 1、数组中的元素必须是同一种数据类型，可以是基本数据类型，也可以是引用数据类型 2、获取数组元素需要使用下标来获取，下标范围[0,length-1] 3、数组在定义的时候必须指定大小，并且一旦指定大小之后是不能修改的 4、数组中的元素是有序集合，这个有序指的不是大小排序，指的按照插入的先后顺序 使用： 1、声明数组 2、分配空间 3、赋值 4、 数组元素的默认初始化： 数组在定义的时候，每个数组元素都会有默认值，系统会根据数组元素数据类型默认进行初始化工作 i
JAVA 作业笔记
最新发布
weixin_54913430的博客
11-09 141
注：Java语言中声明数组时不能指定其长度（数组中元素的个数），这是因为数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量（也就是定一个了一个指针），这个引用变量还未指向任何有效的内存，所以定义数组时不能指定数组的长度。而且由于定义数组仅仅只是定一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有在数组进行初始化后才可以使用。在java语言中，声明数组时不能指定其长度（数组中元素的个数）。3.获取随机数的公式是;
ThinkPHP学习笔记（七）深入学习数据库查询
阿福的专栏
08-08 1696
一、建立项目与配置项目及数据库基本操作等内容：请参考《ThinkPHP学习笔记（一 ~ 六）》 二、数据库查询方法实例： 数据库数据 首先在C层IndexAction.class.php中添加public function searchMethodOne() {}方法，并且在V层添加searchMethodOne.html 文件 1、普通查询方式： 1>  where("
20200715-二维数组及Arrays 类
weixin_47880716的博客
07-15 380
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如： int[][] a=new int[b][c]; int 可以为基本数据类型和复合数据类型，b 和 c 必须为正整数，b 为行数，c 为列数。 二维数组的动态初始化 1.直接为每一维分配空间，格式如下： int[][] a=new int[3][5]; 解析：二维数组 a 可以看成一个3行5列的数组。 2.从最高维开始，分别为每一维分配空间，例如： a[0][0]=1; a[1][5]=5; int[][

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AmazingMing_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值