数组
在java中，数组属于引用数据类型，所以在数组操作过程中，一定会牵扯到内存的分配问题。
1 声明并开辟数组
数据类型 数组名称 [] = new 数据类型 [长度] ;
数据类型 [] 数组名称 = new 数据类型 [长度] ;
2 分步完成
声明数组 : 数据类型 数组类型 [] = null ;
开辟数组 : 数组名称 = new 数据类型 [长度] ;
java为了方便数组的使用 ，提供了"数组名称 . length"的属性 ,可以取得数组的长度 。
public class TestDemo1
{
public static void main(String args[]){
int data [] =new int [3] ; // 动态定义数组
data[0]=0;
data[1]=1;
data[2]=2;
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
System.out.print("
");
int data1[] =null ; //分步动态初始化数组
data1=new int [3];
data1[0]=1;
for(int j=0;j<data1.length;j++){
System.out.print(data1[j]+" ");
}
System.out.print("
");
int data2[]=new int []{9,8,7};
for(int k=0;k<data2.length;k++){
System.out.print(data2[k]+" ");
}
}
}
程序执行结果 ：0 1 2
1 0 0
9 8 7
上述代码分别用不同的方式定义了三个数组 。真麻烦。。。
数组的引用
public class TestDemo1
{
public static void main(String args[]){
int data [] =new int [3] ; // 动态定义数组
data[0]=0;
data[1]=1;
data[2]=2;
int data1[]=data ;
data1[0]=2;
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
}
}
程序执行结果 ：2 1 2
还是可以把数组名理解为栈内存 ，他指向一块堆内存 。一块堆内存可以同时被多个栈内存指向 。
二维数组
动态初始化:数组类型 数组名称 [][] =new 数据类型 [行的个数][列的个数];
静态初始化:数组类型 数组名称 [][]= new 数组类型 [][]{{值，值},{值，值}}。
public class TestDemo1
{
public static void main(String args[]){
int data[][]=new int[][]{{1,2,3},{9,8,7}};
for(int i=0;i<data.length;i++){
for(int j=0;j<data[i].length;j++){
System.out.print(data[i][j]+" ");
}
System.out.println();
}
}
}
程序执行结果 ：1 2 3
9 8 7
数组做方法参数传递
public class TestDemo1
{
public static void main(String args[]){
int data[]= new int []{1,2,3};
ok(data);
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
}
public static void ok(int temp[]){
for(int i=0;i<temp.length;i++){
temp[i]*=2;
}
}
}
程序执行结果 ：2 4 6
方法返回数组
public class TestDemo1
{
public static void main(String args[]){
int data[]=ok();
for(int i=0;i<data.length;i++){
System.out.print(data[i]+" ");
}
System.out.print("数组长度："+ok().length);
}
public static int [] ok(){
return new int []{8,5,7};
}
}
程序执行结果 ：8 5 7 数组长度：3
上述代码 ，使用ok（）方法返回一个数组 ，只需要将方法的返回值改为数组即可 ，返回的可以理解为一个堆内存，让栈内存指向他 。我们也可以直接调用length属性取得长度。
数组操作方法
1：数组复制
System.arraycopy(原数组名称 ，原数组开始下标 ，目标数组名称，目标数组开始下标，长度);
public class TestDemo1
{
public static void main(String args[]){
int data[]=new int []{1,2,3,4,5,6};
int data1[]=new int []{9,8,7,6,5,4,3,2,1};
System.arraycopy(data,1,data1,0,5);
for(int i=0;i<data1.length;i++){
System.out.print(data1[i]+" ");
}
}
}
程序执行结果 ：2 3 4 5 6 4 3 2 1
2：数组排序
java.util.Arrays.sort(数组名称);
需要注意的是，上面的代码只能从小到大排序 。
java .util是java的系统包，Arrays是系统提供的一个类 。
public class TestDemo1
{
public static void main(String args[]){
int data1[]=new int []{9,8,7,6,5,4,3,2,1};
java.util.Arrays.sort(data1);
for(int i=0;i<data1.length;i++){
System.out.print(data1[i]+" ");
}
}
}
程序执行结果 ：1 2 3 4 5 6 7 8 9
对象数组
数组是引用类型，类也是引用类型 ，对象数组表示一个引用类型里嵌套其他的引用类型。
格式：对象数组的动态初始化
类名称 对象数组的名称=new 类名称 [长度] ;
格式：对象数组的静态初始化
类名称 对象数组名称=new 类名称 []{实例化对象，实例化对象...} ;
class Book //定义一个Book类
{
private String title; //图书名称 private封装属性
private double price ; //图书价格 private封装属性
public Book(String p,double q){ //构造方法 初始化对象
title = p;
price = q;
}
public void setTitle(String t){
title = t;
}
public void setPrice(double t){
price = t;
}
public String getTitle(){
return title ;
}
public double getPrice(){
return price;
}
public String getInfo(){
return "图书的名称是："+title+" 图书的价格是："+price;
}
}
public class TestDemo
{
public static void main(String args[]){
Book bk[]=new Book[3]; //动态初始化对象数组
bk[0]= new Book("java开发大全",123.987);
bk[1]= new Book("jsp开发",88.99);
bk[2]= new Book("算法初探",85.7);
for(int i=0;i<bk.length;i++){
System.out.println(bk[i].getInfo());
}
System.out.println();
//静态初始化对象数组
Book bk1[] =new Book[]{new Book("java开发大全",123.987),new Book("jsp开发",88.99),new Book("算法初探",85.7)};
for(int j=0;j<bk.length;j++){
System.out.println(bk1[j].getInfo());
}
}
}
程序执行结果 ：
图书的名称是：java开发大全 图书的价格是：123.987
图书的名称是：jsp开发 图书的价格是：88.99
图书的名称是：算法初探 图书的价格是：85.7
图书的名称是：java开发大全 图书的价格是：123.987
图书的名称是：jsp开发 图书的价格是：88.99
图书的名称是：算法初探 图书的价格是：85.7
对象数组最大的好处就是将多个对象统一进行管理，并且除了数据类型以外，和之前的数组没有区别 。
可以把对象数组名理解为栈内存，储存堆内存地址。在这里声明栈内存的时候，需要使用关键字new。在开辟堆内存的时候，又需要使用一次new。。。。。。