java数组基础

*/

.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
color: #333;
background: #f8f8f8;
}

.hljs-comment,
.hljs-template_comment,
.diff .hljs-header,
.hljs-javadoc {
color: #998;
font-style: italic;
}

.hljs-keyword,
.css .rule .hljs-keyword,
.hljs-winutils,
.javascript .hljs-title,
.nginx .hljs-title,
.hljs-subst,
.hljs-request,
.hljs-status {
color: #333;
font-weight: bold;
}

.hljs-number,
.hljs-hexcolor,
.ruby .hljs-constant {
color: #099;
}

.hljs-string,
.hljs-tag .hljs-value,
.hljs-phpdoc,
.tex .hljs-formula {
color: #d14;
}

.hljs-title,
.hljs-id,
.coffeescript .hljs-params,
.scss .hljs-preprocessor {
color: #900;
font-weight: bold;
}

.javascript .hljs-title,
.lisp .hljs-title,
.clojure .hljs-title,
.hljs-subst {
font-weight: normal;
}

.hljs-class .hljs-title,
.haskell .hljs-type,
.vhdl .hljs-literal,
.tex .hljs-command {
color: #458;
font-weight: bold;
}

.hljs-tag,
.hljs-tag .hljs-title,
.hljs-rules .hljs-property,
.django .hljs-tag .hljs-keyword {
color: #000080;
font-weight: normal;
}

.hljs-attribute,
.hljs-variable,
.lisp .hljs-body {
color: #008080;
}

.hljs-regexp {
color: #009926;
}

.hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.lisp .hljs-keyword,
.tex .hljs-special,
.hljs-prompt {
color: #990073;
}

.hljs-built_in,
.lisp .hljs-title,
.clojure .hljs-built_in {
color: #0086b3;
}

.hljs-preprocessor,
.hljs-pragma,
.hljs-pi,
.hljs-doctype,
.hljs-shebang,
.hljs-cdata {
color: #999;
font-weight: bold;
}

.hljs-deletion {
background: #fdd;
}

.hljs-addition {
background: #dfd;
}

.diff .hljs-change {
background: #0086b3;
}

.hljs-chunk {
color: #aaa;
}

#container {
padding: 15px;
}
pre {
border: 1px solid #ccc;
border-radius: 4px;
display: block;
background-color: #f8f8f8;
}
pre code {
white-space: pre-wrap;
}
.hljs,
code {
font-family: Monaco, Menlo, Consolas, 'Courier New', monospace;
}
:not(pre) > code {
padding: 2px 4px;
font-size: 90%;
color: #c7254e;
background-color: #f9f2f4;
white-space: nowrap;
border-radius: 4px;
}
-->

java中的数组是引用数据类型。

//在栈空间声明数组引用对象
int[] NAME;
int NAME[];    //中括号放哪边都是等价的
className[] NAME;

//在堆空间划分数组空间并初始化数组对象
NAME = new int[3];
NAME = new className[3]

//赋值,在堆空间中填充每个数组成员
NAME[0]=0;NAME[1]=1;...
className[0]=...

//声明数组时直接赋值
int[] NAME = {1,2,3};
className[] NAME = {new className(1),new className(2),...};

根据数据类型可分为两种类型：

• (1).基础数据类型的数组。只是数组内的数据类型是基础的，数组本身仍然是引用类型，毕竟数组有两段内存空间(栈中引用变量，堆中数组对象)。
  例如：int[] a = new int[3];表示数组中有三个成员：a[0]、a[1]和a[2]。
• (2).引用数据类型的数组。例如有一个date类，则可以date[] d = new date[3];，表示数组中有3个成员date[0]、date[1]和date[2]，但每个date[*]成员自身又是一个引用对象，继续引用实际的date对象。具体的见下文。

注意，在划分数组空间时的array[N]中，N表示的是N个对应数据类型的成员。如果是基础数据类型的数组，则N就是N个基础数据的值，例如int[3]可以是{1,2,3}、{5,6,7}。如果是引用数据类型的数组，则N就是N个引用对象。

以下分别是基础数据类型的数组、引用类型的数组的声明、划分空间初始化和赋值填充的代码示例。

class Date {
    int year,month,day;
    Date(int y,int m,int d) {
        year = y;month = m;day = d;
    }
}

public class Test {
    public static void main(String[] args) {
        //
        int a1[];
        a1 = new int[3];
        a1[0]=3;a1[1]=9;a1[2]=10;
        //
        int[] a2 = new int[3];
        a2[0]=3;a2[1]=9;a2[2]=10;
        //
        int[] a3 = {3,9,10}

        //
        Date[] days1;
        days1 = new Date[3];
        days1[0] =  new Date(2012,3,5);
        days1[1] =  new Date(2013,4,5);
        days1[2] =  new Date(2014,5,5);
        //
        Date[] days2 = new Date[3];
        ...
        //
        Date[] day3 = (new Date(2012,3,5),new Date(2013,4,5),new Date(2014,5,5));
    }
}

二维数组

java中的多维数组可以看作是数组的数组。例如二维数组int a[][]。声明时必须先声明左边的，再声明右边的，因为数组的数组代表没有左边的就没有右边的。

int a[][] = {{1,2},{3,4,5,6},{7,8,9}};
int[][] a = {{1,2},{3,4,5,6},{7,8,9}};

int a[][] = new int[3][];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
a[0][0] = 1;a[0][1] = 2;
int t1[][] = new int[][4];  //错误

遍历数组

遍历一维数组arr[]:

for (int i = 0 ;i<arr.length;i++) {}

for (int i:arr) {}

遍历二维数组arr[][]:

for (int i=0;i<arr.length;i++) {
    for (int j=0;j<arr[i].length;j++) {}
}

for (int i[]:arr) {
    for (int j:i) {}
}

注意，使用foreach遍历方式时，type s:array的type和array的type必须能够兼容，此处的s就代表各个数组成员的值。

例如：

String s[] = {"Microsoft","IBM","Apple","Oracle","AliBaBa"}
for (String x:s) {           // type = String
    System.out.println(x);   // s = "Microsoft","IBM","Apple","Oracle","AliBaBa"
}

对于不想遍历而是只想输出数组的全部元素值，可以采用java.util.Arrays类的toString()方法。

Integer[] nums = {1,2,3,4};
System.out.println(Arrays.toString(nums)); // return: [1, 2, 3, 4]

拷贝数组

java.lang.System类中的arraycopy()方法，因为数组在内存中是连续的，所以可以直接拷贝内存实现数组成员的拷贝。

System.arraycopy(src,src_start_pos,dest,dest_start_pos,length)

表示将src数组从src_start_pos位置开始复制，总共复制length个成员到dest数组中的第dest_start_pos处。注意可能会数组下标越界。

String s[] = {"Microsoft","IBM","Apple","Oracle","AliBaBa"}
String sbak[] = new String[6];
System.arraycopy(s,0,sbak,0,s.length)

但System.arraycopy()只支持同数据类型的数组进行copy，例如无法将int[] copy 到String[]中。此时只能使用遍历copy的方式一个元素一个元素地copy。

import java.util.Arrays;
int[] nums = {1,2,3,4};
String[]  snums = new String[nums.length];
for (int i=0;i<nums.length;i++) {
    snums[i] = Integer.valueOf(nums[i]).toString();
}
System.out.println(Arrays.toString(snums));

main(String[] args)

public static void main(String[] args) {}的main()方法中，参数为数组类型，数组名为args。参数的内容是java命令行传递的各个值。

既然args是数组名，所以也可以使用其他字符替换args。因为是数组，所以数组的一些特性就可以使用，例如arg[0]、arg[1]、args.length等。

例如:

public class TestArray {
    public static void main(String [] args) {
        System.out.println(args[0] + "-" + args[1] + "-" + args[2]);
    }
}

执行时，传递参数1、2、3.

java Test 1 2 3
执行结果：
1-2-3

注：若您觉得这篇文章还不错请点击右下角推荐，您的支持能激发作者更大的写作热情，非常感谢！