java---数组

最新推荐文章于 2021-03-11 11:37:31 发布
最新推荐文章于 2021-03-11 11:37:31 发布
阅读量958 收藏 2
点赞数
分类专栏： java 文章标签： 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x283930450/article/details/13096893
版权

1.数组的定义：

       数组是具有相同数据类型的一组数据的集合。
       Java中虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象，在程序设计中引入数组可以更有效地管理和处理数据。

一维数组：

声明：数组元素类型[ ] 数组名字;（记住：数组名是引用类型变量）

创建空间：数组作为对象，使用new关键字进行内存分配。

注意：数组的大小一旦指定，就不可更改。       
          数组空间创建后具有默认的初值 

          数值类型的数组元素默认值为0
          char数组中，每个值都被初始化为0(\u0000)字符；
          boolean类型的数组元素默认值为false
          对象类型的数组元素默认值为null
声明、创建、默认初始化一步完成：
eg. char []s = new char [20]; 
      Point p [] = new Point [100];
      int score[]=new int[]{1,2,4};（注意红色中括号中不能指明大小）
      Point p[] = { new Point(), new Point(1,2)};

二维数组：
二维数组是每个元素是一维数组的数组。
以此类推，N维数组就是每个元素是N-1维数组的数组。
声明：数组元素类型  [ ][ ]   数组名字;
创建空间：a=new int[4][5];
声明、创建、默认初始化一步完成：
eg. int [][] a = new int[4][5];

访问数组
通过下标进行，如a[5]或者a[8],  b[1][3].
数组的下标都从0开始，到数组名.length-1
例如：int[] a=new int[10];
          a[0]=10;    a[5]=2;    a[9]=100;
数组被看成对象，具有length属性, 存储数组元素的个数值。
数组元素下标范围: [0 , 数组名.length)

2.遍历数组：
遍历一维数组： 
                int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + " ");
		System.out.println();

		for (int i : a)
			System.out.print(i + " ");
		System.out.println();


遍历二维数组： 
                int[][] a = { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 } };

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

		for (int[] i : a) {
			for (int j : i)
				System.out.print(j + " ");
			System.out.println();
		}
3.复制数组：
第一（复制数组）：Arrays.copyOf(int[] original,int newLength);
original - 要复制的数组
newLength - 要返回的副本的长度         
          
具体说明：
copyOf
 public static short[] copyOf(short[] original,int newLength)                                                   复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 (short)0。当且仅当指定长度大于原数组的长度时，这些索引存在。                                                                                                 参数：original - 要复制的数组                                                                                                 newLength - 要返回的副本的长度                                                                       返回：原数组的副本，截取或用 0 填充以获得指定的长度                                               抛出：NegativeArraySizeException - 如果 newLength 为负                                                     NullPointerException - 如果 original 为 null                                                         从以下版本开始：1.6
具体例子： 
                int[] array = { 01, 2, 3, 4, };   // 定义整型数组
		
		System.out.print("原数组：");
		for (int i : array) {   // 遍历输出数组
			System.out.print(i + " ");
		}
		System.out.println();
		
		int[] arrayCopy = Arrays.copyOf(array, 6);// 复制数组
		
		System.out.print("复制数组：");
		for (int i : arrayCopy) {// 遍历输出数组
			System.out.print(i + " ");
		}
		System.out.println();
运行结果为：
原数组：1 2 3 4 
复制数组：1 2 3 4 0 0

第二（部分复制数组）：Arrays.copyOfRange(int[] original,int front,int to);
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引（包括）
to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。

具体说明：
 copyOfRange
 public static int[] copyOfRange(int[] original,int from,int to)                                                      将指定数组的指定范围复制到一个新数组。该范围的初始索引 (from) 必须位于 0 和 original.length（包括）之间。original[from] 处的值放入副本的初始元素中（除非 from == original.length 或 from == to）。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)（必须大于等于 from）可以大于 original.length，在这种情况下，0 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from。 
参数：original - 将要从其复制一个范围的数组  
          from - 要复制的范围的初始索引（包括）  
          to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度                 抛出：ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length()                IllegalArgumentException - 如果 from > to                                                                    NullPointerException - 如果 original 为 null                                                       从以下版本开始：1.6
具体例子： 
                int[] array = { 01, 2, 3, 4, };   // 定义整型数组
		
		System.out.print("原数组：");
		for (int i : array) {   // 遍历输出数组
			System.out.print(i + " ");
		}
		System.out.println();
		
		int[] arrayRangeCopy = Arrays.copyOfRange(array, 2, 6);// 部分复制数组
		
		System.out.print("部分复制数组：");
		for (int i : arrayRangeCopy) {// 遍历输出数组
			System.out.print(i + " ");
		}
		System.out.println();
运行结果为：
原数组：1 2 3 4 
部分复制数组：3 4 0 0 

第三：System.arraycopy(Object src,int srcPos,Object dest,int destPos,int Length);
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。具体说明：
具体例子： 
int[] array = { 01, 2, 3, 4, };   // 定义整型数组
		
		System.out.print("原数组：");
		for (int i : array) {   // 遍历输出数组
			System.out.print(i + " ");
		}
		System.out.println();
		
		int myArray[] = new int[10];
		System.arraycopy(array, 1, myArray, 3, 2);

		System.out.print("用System的arraycopy复制数组：");
		for (int i : myArray) {// 遍历输出数组
			System.out.print(i + " ");
		}
运行结果为： 
原数组：1 2 3 4  
用System的arraycopy复制数组：0 0 0 2 3 0 0 0 0 0
第四：System.arraycopy(Object src,int srcPos,Object dest,int length);
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
具体说明：
arraycopy
 public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从 src 引用的源数组到 dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于length 参数。源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。                          如果参数src和dest引用相同的数组对象，则复制的执行过程就好像首先将srcPos到srcPos+length-1 位置的组件复制到一个带有 length 组件的临时数组，然后再将此临时数组的内容复制到目标数组的 destPos 到 destPos+length-1 位置一样。                           If 如果 dest 为 null，则抛出 NullPointerException 异常。                                          如果 src 为 null, 则抛出 NullPointerException 异常，并且不会修改目标数组。               否则，只要下列任何情况为真，则抛出 ArrayStoreException 异常并且不会修改目标数组：                                                                                                                             •src 参数指的是非数组对象。                                                                                       •dest 参数指的是非数组对象。                                                                                     •src 参数和 dest 参数指的是那些其组件类型为不同基本类型的数组。                           •src 参数指的是具有基本组件类型的数组且 dest 参数指的是具有引用组件类型的数组。•src 参数指的是具有引用组件类型的数组且 dest 参数指的是具有基本组件类型的数组。否则，只要下列任何情况为真，则抛出 IndexOutOfBoundsException 异常，并且不会修改目标数组：                                                                                                           •srcPos 参数为负。                                                                                                     •destPos 参数为负。                                                                                                   •length 参数为负。                                                                                                       •srcPos+length 大于 src.length，即源数组的长度。                                                     •destPos+length 大于 dest.length，即目标数组的长度。                                              否则，如果源数组中 srcPos 到 srcPos+length-1 位置上的实际组件通过分配转换并不能转换成目标数组的组件类型，则抛出 ArrayStoreException 异常。在这种情况下，将 k 设置为比长度小的最小非负整数，这样就无法将 src[srcPos+k] 转换为目标数组的组件类型；当抛出异常时，从srcPos 到srcPos+k-1 位置上的源数组组件已经被复制到目标数组中的 destPos 到 destPos+k-1 位置，而目标数组中的其他位置不会被修改。（因为已经详细说明过的那些限制，只能将此段落有效地应用于两个数组都有引用类型的组件类型的情况。）                                                                                                           参数：src - 源数组。                                                                                                              srcPos - 源数组中的起始位置。                                                                                    dest - 目标数组。                                                                                                         destPos - 目标数据中的起始位置。                                                                              length - 要复制的数组元素的数量。                                                                    抛出：IndexOutOfBoundsException - 如果复制会导致对数组范围以外的数据的访问。           ArrayStoreException - 如果因为类型不匹配而使得无法将 src 数组中的元素存储到 dest 数组中。                                                                                                                      NullPointerException - 如果 src 或 dest 为 null。
具体例子： 
                int myArray[] = { 1, 2, 3, 4, 5, 6 };
		int yourArray[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

		System.arraycopy(myArray, 0, yourArray, 0, myArray.length);
		
		for (int j = 0; j < yourArray.length; j++) {
			System.out.print(yourArray[j] + " ");
		}
		System.out.println();
运行结果为：
1 2 3 4 5 6 4 3 2 1 

4.填充数组：Arrays.fill(int[] a,int val);
a - 要填充的数组
val - 要存储在数组所有元素中的值
具体说明：
fill
 public static void fill(int[] a,int val)                                           
      将指定的 int 值分配给指定 int 型数组的每个元素。                                               参数：a - 要填充的数组                                                                                                          val - 要存储在数组所有元素中的值
具体例子：
 
     int[] array = new int[5];// 定义能保存5个元素的数组
        Arrays.fill(array, 5);// 将数组中全部元素赋值为5
        System.out.println("数组中的元素");
        for (int i : array) {// 遍历输出数组元素
            System.out.print(i + " ");
        }
运行结果为：
数组中的元素
5 5 5 5 5 

5.数组的排序：Arrays.sort(int[] a);
              a - 要排序的数组
对指定的 int 型数组按数字升序进行排序。
具体例子： 
                int[] array = { 5, 4, 3, 2, 1 };// 定义整型数组
		System.out.println("排序前数组元素：");
		for (int i : array) {// 遍历数组
			System.out.print(i + " ");
		}

		System.out.println();
		Arrays.sort(array);// 将数组排序
		System.out.println("排序后数组元素：");
		for (int i : array) {// 遍历数组
			System.out.print(i + " ");
		}
运行结果为：
 
排序前数组元素：
5 4 3 2 1 
排序后数组元素：
1 2 3 4 5
采用冒泡算法（真正的冒泡）对一维数组进行排序：
 
public class maopao {

	public static void main(String[] args) {
		int a[] = { 3, 1, 2345, 3, 78, 5, 234 };

		for (int x : a) {
			System.out.print(x + " ");
		}
		System.out.println("\n");

		for (int i = 0; i < a.length - 1; i++) {
			for (int j = a.length - 1; j >= i + 1; j--) {
				if (a[j] < a[j - 1]) {
					int t = a[j];
					a[j] = a[j - 1];
					a[j - 1] = t;
				}
			}
			for (int x : a) {
				System.out.print(x + " ");
			}
			System.out.println();
		}
	}
}
运行结果为： 
3 1 2345 3 78 5 234 

1 3 3 2345 5 78 234 
1 3 3 5 2345 78 234 
1 3 3 5 78 2345 234 
1 3 3 5 78 234 2345 
1 3 3 5 78 234 2345 
1 3 3 5 78 234 2345
6.数组的查找：Arrays.binarySearch(int[] a,int key);
a - 要搜索的数组
key - 要搜索的值
具体说明：
binarySearch
 public static int binarySearch(int[] a,int key) 
      使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：a - 要搜索的数组
         key - 要搜索的值 
返回：如果它包含在数组中，则返回搜索键的索引;否则返回 (-(插入点) - 1)。
插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
具体例子：
 
                int[] array = { 5, 4, 3, 2, 1 };// 定义整型数组
		System.out.print("数组中的元素：");
		for (int i : array) {// 遍历数组
			System.out.print(i + " ");
		}
		System.out.println();
		Arrays.sort(array);// 将数组排序

		int index = Arrays.binarySearch(array, 0);// 查找元素0在数组中的索引值,注意查找之前必须先把数组排好序
		System.out.println("元素0在数组中的索引值：" + index);
		index = Arrays.binarySearch(array, 2);// 查找元素0在数组中的索引值
		System.out.println("元素2在数组中的索引值：" + index);
运行结果为： 
数组中的元素：5 4 3 2 1 
元素0在数组中的索引值：-1
元素2在数组中的索引值：1
7.互换二维数组的行列： 
import java.util.Scanner;

public class Transposition {
	public static void main(String[] args) {
		int hang, lie;
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入原始二维数组的行数、列数：");
		hang = sc.nextInt();
		lie = sc.nextInt();
		System.out.println();

		int[][] array = new int[hang][lie];// 定义二维数组
		int[][] arrayT = new int[lie][hang];// 定义转置后的二维数组

		System.out.println("请输入原始二维数组的元素：");
		for (int i = 0; i < array.length; i++) {// 对二维数组中的元素进行赋值
			for (int j = 0; j < array[i].length; j++) {
				array[i][j] = sc.nextInt();
			}
		}
		System.out.println();

		System.out.println("原始二维数组的元素如下：");
		for (int i = 0; i < array.length; i++) {// 对二维数组中的元素进行赋值
			for (int j = 0; j < array[i].length; j++) {
				System.out.print(array[i][j] + " ");// 输出数组中的元素
			}
			System.out.println();
		}
		System.out.println();

		System.out.println("转置后的二维数组元素：");
		for (int i = 0; i < arrayT.length; i++) {// 实现二维数组转置
			for (int j = 0; j < arrayT[i].length; j++) {
				arrayT[i][j] = array[j][i];
				System.out.print(arrayT[i][j] + " ");// 输出数组中的元素
			}
			System.out.println();
		}
		sc.close();
	}
}
运行结果为： 
请输入原始二维数组的行数、列数：
3 4

请输入原始二维数组的元素：
8 5 6 4
3 5 7 1
0 8 4 2

原始二维数组的元素如下：
8 5 6 4 
3 5 7 1 
0 8 4 2 

转置后的二维数组元素：
8 3 0 
5 5 8 
6 7 4 
4 1 2
8.利用二维数组存储并输出杨辉三角的前n（n的值自己指定）行。

1

11

12 1

13 3 1

14 6 4 1

import java.util.Scanner;

public class five {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("输入行数：");
		int hang = sc.nextInt();
		// 声明二维数组
		int[][] a = new int[hang][];
		// 给每行创建空间
		for (int i = 0; i < a.length; i++) {
			a[i] = new int[i + 1];
		}
		// 赋值1
		for (int i = 0; i < a.length; i++) {
			a[i][0] = 1;
			a[i][i] = 1;
		}
		// 给中间那块赋值
		for (int i = 2; i < a.length; i++) {
			for (int j = 1; j < i; j++) {
				a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
			}
		}
		// 打印
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				System.out.print(a[i][j] + "\t");
			}
			System.out.println();
		}
		sc.close();
	}
}
运行结果为： 
输入行数：
11
1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1	
1	10	45	120	210	252	210	120	45	10	1
9.编写程序利用二维数组存储九九乘法表，并输出该乘法表。
 
public class six {
	public static void main(String[] args) {

		String[][] a = new String[9][];

		for (int i = 0; i < a.length; i++) {
			a[i] = new String[i + 1];

			for (int j = 0; j < a[i].length; j++) {
				a[i][j] = (j + 1) + "*" + (i + 1) + "=" + (i + 1) * (j + 1);
			}
		}

		// 遍历输出
		for (String[] x : a) {
			for (String y : x)
				System.out.print(y + "\t");
			System.out.println();
		}
	}
}
运行结果为： 
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81


持续学习刻意练习
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-05-20
weixin_51186288的博客
05-20 67
01、什么是数组 数组是相同数据类型的有序集合 数组的描述是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每一个数据称作一个数据元素，每个数组元素可以通过一个下标来访问 02、数组的声明和创建 首先必须声明数组变量，才能在数组中使用数组，数组语法： detaType[] arrayRefVar;//首选的方法 detaType arrayRefVar[];//效果相同不建议使用 java语言使用new操作符来创建数组，语法： dataTy.
Java –如何将原始数组转换为列表
一名可爱的技术搬运工
05-29 189
代码片段将原始数组int[]转换为List<Integer> ： int[] number = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; List<Integer> list = new ArrayList<>(); for (int i : number) { list.add(i); } 在Java 8中...
java排序算法选择题,Java排序算法专题
weixin_39902085的博客
03-11 172
今天晚上做了一下LeetCode上的Median of Two Sorted Arrays这道题，没想到一次性通过了。随即想要归纳整理一下排序算法，废话少说，我们开始吧。选择排序这是一种最简单直观的排序算法，它的工作原理如下：每一趟从待排序的数列中选出最小的(最大的)一个元素，顺序放到已经排好序的数列的最后，直到所有待排元素全部排好。选择排序是稳定的排序算法，最坏时间复杂度是O(n^2) ，最优时...
选择排序和冒泡排序
LBJ
10-16 512
/* 选择 (从小到大排序) int a[5] = {5,4,3,2,1}; a[0] a[1] a[2] a[3] a[4] 5 4 3 2 1 1 5 4 3 2 第一轮比较（拿a[0]和后面的元素依次比较 如果a[0]>a[i]那么两个数交换） 1 2 5 4
Java数组详解
Chennile的博客
10-06 232
三种定义数组的格式 int[] arr1=new int[10]; int[] arr2={1,2,3,6}; int[] arr3=new int[]{1,2,3,4,5,6,7,22}; //注意：数组的length是一个属性，而字符串的length()是一个方法了！！！虽然都是求的他们各自的长度 System.out.println(arr.length); 其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然
java----数组----最值问题
07-14
定义数组scores并赋值56,90,34,20,统计出最高分,最低分,平均分
JAVA-数组进制转换
10-08
.java文件，对java基础的数组部分的进制类型转换部分的说明。
Java学习资料-数组
最新发布
06-15
Java中的数组是编程中不可或缺的基础概念，主要用于存储一组...总之，Java数组提供了一种高效、有序的方式来存储和操作一组相同类型的数据，是编程中常用的数据结构。理解和熟练使用数组是掌握Java编程的关键步骤之一。
java5-数组
12-11
java5-数组
Java基础--数组练习2
07-25
Java基础之数组练习2
Java 基础 - 5
枯寂家博客
11-06 346
五、Java 数组 1. 数组的概述 >数组（Array）,是多个相同类型数据按一定顺序排序的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理 >数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型 >数组的长度一旦确定，就不能修改 >数组的分类： a.按照维度：一维数组、二维数组、三维数组、…… ...
JAVA学习-数组元素排序
weixin_43545253的博客
02-09 334
JAVA实现数组元素排序，把数组中已知的10个数字由小到大排序后输出 代码： public class ArraryRank {//定义公共类 public static void main(String[] args) {//运行主函数 int[] a = { 7, 8, 9, 3, 6, 5, 4, 10, 2, 1 };//创建原始数组 System.out.println("原始数组：");//打印出“原始数组”提示 for (int i = 0; i < a.length; i
个渣渣C语言之数组
dianzhi8696的博客
11-02 146
---恢复内容开始--- 　　学c语言就知道数组、指针在c中有着特殊的地位。而且是必须掌握的一项知识，学会它会让你受益无穷。 　　一、数组 　　1、数组：室友一系列相同元素构成的。它连续的存储在内存中。 　　2、数组的声明： 　　　　格式： 类型 数组名 [元素个数]； 　　　　例 ： int myarray[10]; 　　　　注意：在c99之前不允许出现元素个数为变量...
求System.arraycopy的用法
weixin_30918415的博客
11-08 78
public class Shuzufuzhi {public static void main(String args[]){int myArray[]={1,2,3,4,5,6};int yourArray[]={10,9,8,7,6,5,4,3,2,1};int Array3 []=new int [myArray.length+yourArray.length];S...
关于int a[5]; 使用了a[5]、a[6]等的问题
vvull的博客
07-16 1598
Java中数组的定义及初始化
热门推荐
lemon_fight的博客
10-13 19万+
定义格式 数组类型[] 数组名 = new 数据类型[数组长度];  其中，数据类型可以是8种基本的数据类型，也可以是引用数据类型。 注意： 在给数组命名的时候，一般在数组名后加一个 s 表示这是一个包含多个元素的数组（与单个变量区分）。 eg: int[] arrays = new int[5]; //定义了一个包含整型元素的数组 ...
Java基础--6--数组
武天旭的博客
06-01 489
1、理论基础 程序=算法+数据结构 算法：解决问题的流程。第一步、第二步、第三步……干什么。有顺序、分支、循环三种方式。 数据结构：把数据按特定的某种结构保存，设计合理的数据结构是解决问题的前提。 数组就是最基本的一种数据结构。它用来存储一系列数据，其中的每一项都具有相同的基本数据类型、类或相同的父类，每一项都有自己的位置，因此可以通过下标来进行定位。 数组的定义： 1、相同数据类型的元素组成的集合。 2、元素按照线性顺序排列。即一个挨一个，中间不能有空缺。 3、可以通过元素所在位置的顺序号做标识来访
java数组的三种初始化方式
Blog 微笑的草莓丶
04-03 16万+
2018年4月3日Java语言中数组必须先初始化，然后才可以使用。所谓初始化就是为数组的数组元素分配内存空间，并为每个数组元素附初始值。注意：数组完成初始化后，内存空间中针对该数组的各个元素就有个一个默认值：            基本数据类型的整数类型（byte、short、int、long）默认值是0；            基本数据类型的浮点类型（float、double）默认值是0.0； ...
java数组知识
qq_38497266的博客
05-22 413
数组用来存储一个元素个数固定且元素类型相同的有序集。 一维数组 声明数组变量： //一、元素类型[] 数组引用变量；(推荐使用) int[] myArray; //二、元素类型 数组引用变量[]； int myArray[]; 创建数组：不同于基本数据类型变量的声明，声明一个数组变量时并不在内存中给数组分配任何空间，只是创建了一个对数组的引用的存储位置。声明变量后，可以使用下面语法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值