1.一个数组是一系列匿名变量，数组就是一些相关变量的集合，数组中的元素可以通过下标来进行访问。类Object中定义的方法都可以用于数组对象。数组元素可以是基本类型也可以是类类型，当然还可以是数组。数组在使用之前必须先说明，也就是要先定义！
数组定义语法如下：
动态初始化
①声明并开辟数组：数据类型 数组名称[]=new 数据类型[长度]; ([]也可以写在数组名称前面)
②分布完成： 声明数组： 数据类型 数组名称[]=null;
开辟数组： 数组名称=new 数据类型[长度];
静态初始化
①数据类型 数组名称[]=｛值，值.......，值｝;
②数据类型 数组名称[]=new 数据类型[]｛值，值.......，值｝;
当数组开辟空间之后，那么可以采用“数组名称[下标or索引]”的形式进行访问，但是所有数组的下标都是从0开始的，即如果是三个长度的数组那么其下标范围为：0~2。如果访问的时候超过了数组的允许下标的长度那么会出现数组越界异常（ArrayIndexOutOfBoundsException）
以上给出的数组定义结构使用的都是动态初始化的方式:即数组会首先开辟内存空间，但是数组中的内容都是其对应数据类型的默认值。还有静态初始化的方式：数组定义的同时就设置好了相应的数据内容
数组也是引用数据类型！！！！！与对象保存的区别在：对象中的堆内存保存的是属性，而数组中的堆内存保存的是一组信息。
数组与方法参数的传递
一个数组传递的程序（冒泡排序）：
public class Test {
public static void change(int[] a) // int[] a =m;
{
for(int i=0;i<a.length;i++)
{
a[i]*=2;//将数组a中元素值扩大两倍并保存
}
}//此方法定义在主类中，并由主方法直接调用
public static void main(String[] args) {
int[] m=new int[]{1,2,3,4,5};
change(m);
for(int i=0;i<m.length;i++)
{
System.out.println(m[i]);
}
}
}
在进行数组的引用传递过程中，方法对数组的修改一定会影响到原始数据。
一个数组传递的程序（转置） 该方法无垃圾产生
public class Test {
public static void reverse(int[] arr) // int[] arr =data;
{ int len=arr.length/2;//转置的次数
int head=0;//开始索引
int tail=arr.length-1;//尾部索引
for(int x=0;x<len;x++)
{
int temp=arr[head]; //头尾互相交换
arr[head]=arr[tail];
arr[tail]=temp;
head++;
tail--;
}
}
public static void print(int[] temp) //输出
{
for(int x=0;x<temp.length;x++)
{
System.out.print(temp[x]+"丶");
}
System.out.println();
}
public static void main(String[] args) {
int[] data=new int[]{1,2,3,4,5,6,7};
reverse(data);//实现转置
print(data);
}
}
数组操作方法
①数组拷贝：可以将一个数组的部分内容拷贝到另外一个数组中
语法：System.arraycopy(源数组名称，源数组拷贝起始下标，目标数组，目标数组拷贝起始下标，长度)
范例：实现数组拷贝
public class Test {
public static void print(int[] temp) //输出
{
for(int x=0;x<temp.length;x++)
{
System.out.print(temp[x]+"丶");
}
System.out.println();
}
public static void main(String[] args) {
int[] a=new int[] {1,2,3,4,5,6,7};
int[] b=new int[] {45,55,69,48,11,33,55};
System.arraycopy(a, 3, b, 3, 3);
print(b);
}
}
②数组排序（这种方法很简单，偷懒才用）
语法：java.util.Arrays.sort(数组名称);
import java.util.Arrays;
public class Test {
public static void print(int[] temp) //输出
{
for(int x=0;x<temp.length;x++)
{
System.out.print(temp[x]+"丶");
}
System.out.println();
}
public static void main(String[] args) {
int[] b=new int[] {45,55,69,48,11,33,55};
Arrays.sort(b);
print(b);
}
}
对象数组（重点）
数组是引用类型，而类同样也是引用类型，所以如果是对象数组的话表示一个引用类型里面嵌套了其他的引用类型。在之前使用的数组都属于基本数据类型的数组，但是所有的引用数据类型也同样可以定义数组，这样的数组称为对象数组。对象数组=多个对象
如果想要定义对象数组（以类为例），可以采用如下方法完成：
·动态初始化：
声明并开辟对象数组→ 类名称 对象数组名称[]=new 类名称[数组长度];
分布完成：
声明对象数组→ 类名称 对象数组名称[]=null;
开辟对象数组→ 对象数组名称=new 类名称[数组长度];
·静态初始化： 类名称 对象数组名称[]=new 类名称[] {实例化对象，实例化对象，......，实例化对象}
范例：动态初始化
class Book{
private String title;
private double price;
public Book(String title,double price)
{
this.title=title;
this.price=price;
}
public String getInfo()
{
return "书名："+title+"价格"+price;
}
}
public class Test {
public static void main(String[] args) {
//开辟了一个三个长度的对象数组
Book[] books=new Book[3];
//对象数组中的每个数据都需要分别实例化
books[0]=new Book("Java",79.8);
books[1]=new Book("JSP",109.8);
books[2]=new Book("Python",89.5);
for(int i=0;i<books.length;i++)
{
System.out.println(books[i].getInfo());
}
}
}
对象数组实际上就是将多个对象交给数组统一管理。
范例：静态初始化
class Book{
private String title;
private double price;
public Book(String title,double price)
{
this.title=title;
this.price=price;
}
public String getInfo()
{
return "书名："+title+"价格"+price;
}
}
public class Test {
public static void main(String[] args) {
//开辟了一个三个长度的对象数组
Book[] books=new Book[] {
new Book("Java",78.9),
new Book("JSP",109.8),
new Book("Python",89.5),
};
//对象数组中的每个数据都需要分别实例化
for(int i=0;i<books.length;i++)
{
System.out.println(books[i].getInfo());
}
}
}