Java数组的定义与使用

数组的基本定义

java里面将数组定义为了引用数据类型，牵扯到内存分配，需要使用关键字new处理。

• 数组的动态初始化:
  声明并初始化数组，初始化之后数组每一个元素的保存内容为其对应数据类型的默认值。
  数据类型 数组名称[]=new 数据类型[长度];
  数据类型 [] 数组名称=new 数据类型[长度];
• 数组的静态初始化：在数组定义的时候就为其设置好了里面的内容；
  简化格式：数据类型 数组名称[]={数据1，数据2，数据3，……}；
  完整格式：数据类型 数组名称[]=new 数据类型[]{数据1，数据2，数据3，……}；

数组引用传递分析

foreach

foreach语法结构可以直接自动获取数组中的每一个元素，避免下标访问。
for(数据类型 变量 : 数组|集合){}
最大的特点在于可以自动将数组中的每一个元素的内容取出保存在变量里面，这样就可以直接通过变量获取数组内容，而避免下标形式。

public class JavaDemoo {    
    public static void main(String[] args) {      
        int data[]=new int[]{1,2,3};           
        for(int temp:data){            
        System.out.println(temp);       
        }
 }}

程序截图：

二维数组

• 数组的动态初始化
  数据类型 数组名称 [][]=new 数据类型[行个数][列个数]
• 静态数组初始化
  数据类型 数组名称 [][]=new 数据类型[][]{数据，数据……}{数据，数据……}

数组与方法

对于引用数据而言，主要特点是可以与方法进行引用传递，而数组本身也属于引用数据类型，自然也可以通过方法进行引用传递。

我们既可以通过方法接受一个数组，那么也就可以通过方法返回一个数组对象，那么对方法的返回值控制即可。

public class JavaDemoo {        
    public static int [] initArray(){       
        int arr[]=new int[]{1,2,3,4,5};       
        return arr;    }    
 public static void printArray(int temp[]){      
    for(int x=00;x< temp.length;x++){          
        System.out.println(temp[x]);      }    }    
public static void main(String[] args) {      
    int data[]=initArray();        
    printArray(data);    }}

数组排序

class ArrayUtil{    public static void sort(int data[]){        for(int x=0;x< data.length;x++){            for(int y=0;y< data.length-x-1;y++){                if(data[y]>data[y+1]){                    int temp=data[y+1];                    data[y+1]=data[y];                    data[y]=temp;                }            }        }    }    public static void printArray(int temp[]){        for(int x=0;x< temp.length;x++){            System.out.print(temp[x]+",");        }        System.out.println();    }}public class sorttt {    public static void main(String[] args) {        int data[]=new int[]{8,9,0,2,3,5,10,7,6,1};        ArrayUtil.sort(data);        ArrayUtil.printArray(data);    }}

数组相关类库

• 数组排序：java.util.Arrays.sort(数组名称)
• 数组拷贝: System.arraycopy(源数组，源数组开始点，目标数组，目标数组开始点，拷贝长度）。

方法可变参数

class ArrayUtil{   
    public static int sum(int ... data){       
        int sum=0;        
        for(int temp:data){            
            sum+=temp;        }        
        return sum;    }}
 public class sorttt {    
    public static void main(String[] args) {  
        System.out.println(ArrayUtil.sum(new int[]{1,2,3,4,5})); 
        System.out.println(ArrayUtil.sum(1,2,3,4,5));    }}

代码public static int sum(int ... data)，中用"…"（可变参数），可变参数最大的作用在于，在以后进行一些程序类设计或者开发者调用的时候，利用此种形式我们可以避免数组的传递操作，但本质依然是数组的传递。

对象数组

之前接触的都是基本数据类型定义的数组，但在Java程序本身各种数据类型都可以成为我们的数组类型，像这样的数组成为对象数组。
定义格式：

• 动态初始化： 类 对象数组名称[]=new 类[长度],每一个元素内容都是null。
• 静态初始化： 类 对象数组名称[]=new 类[]{实例化对象，实例化对象,……}
  动态案例

class ArrayUtil{
    private String name;    
    private int age;    
    public ArrayUtil(String name,int age){              
        this.name=name;        
        this.age=age;    }    
    public String getInfo(){        
        return "姓名"+this.name+"，年龄:"+this.age;    }              public void setName(String name) {        
        this.name = name;    }    
    public void setAge(int age) {        
        this.age = age;    }    
    public String getName() {       
        return name;    }    
    public int getAge() {        
        return age;    }}
 public class sorttt {   
    public static void main(String[] args) {     
        ArrayUtil arr [] =new ArrayUtil[3];        
        arr[0]=new ArrayUtil("夏添",19);        
        arr[1]=new ArrayUtil("夏承",19);        
        arr[2]=new ArrayUtil("夏天",19);        
   for(int x=0;x< arr.length;x++){            System.out.println(arr[x].getInfo());        }    }}

对于静态案例部分：

 ArrayUtil arr [] =new ArrayUtil[3]{new ArrayUtil("夏添",19), new ArrayUtil("夏承",19),new ArrayUtil("夏天",19)}  

所有的开发都不可能离开对象数组，但一个数组中的缺陷是：数组长度是固定的。优势是线性保存，根据索引访问，速度快，时间复杂度为1.