鲁达
感谢大家的支持,你们的支持就是我的动力，如果对您有所帮助，请转发并收藏，谢谢！
数组是一种非常常见的数据结构，在Java中，数组属于引用型数据，所以在数组的操作过程中，也一定会牵扯到内存的分析问题。
一、数组的基本概念
数组的定义格式如下：
1.数组动态初始化：
数据类型 数组名称 [] = new 数组类型 [长度];
数据类型 [] 数据名称 = new 数组类型 [长度];
范例一：
public class TestDemo{
public static void main(String args[]){
int data [] = new int [3]; //开辟3个空间的数组
data[0] = 10; //为数组赋值
data[1] = 20; //为数组赋值
data[2] = 30; //为数组赋值
for(int x = 0 ; x < da ; x++){ //循环输出数组内容
Sy(data[x]+"、");
}
}
}
范例一内存分析：
为数组进行内存分配及操作流程和对象操作几乎是一样的，只不过对象之中保存的是属性，而在数组之中保存的是各个索引元素的数值。
2.分布完成
声明数组:
数据类型 数组名称 [] = null; ----只有声明的时候加上“[]”
开辟数组:
数据名称 = new 数据类型 [长度];
范例二：
public class TestDemo{
public static void main(String args[]){
int data [] = null; //只有声明的时候加上“[]”
data = new int [3]; //开辟3个空间的数组“[]”
data[0] = 10; //为数组赋值
data[1] = 20; //为数组赋值
data[2] = 30; //为数组赋值
for(int x = 0 ; x<da ; x++){
Sy(data[x]+"、");
}
}
}
范例二内存分析：
3.数组的静态初始化
简写格式:
数据类型 数据名称 [] = {值,值,…};
数据类型 [] 数据名称 = {值,值,…};
完整格式(推荐使用):
数据类型 数组名称 [] = new 数据类型 [] {值,值,…};
数据类型 [] 数组名称 = new 数据类型 []{值,值,…};
范例三：
public class TestDemo{
public static void main(String args[]){
int data[] = new int [] {209,201,2,2,3,6,7}; //数组的静态初始化
for(int x = 0 ; x< da ; x++){ //循环输出数组
Sy(data[x]+",");
}
}
}
二、数组的引用传递
范例四：
public class TestDemo{
public static void main(String args[]){
int data [] = new int [3]; //开辟3个空间的数组
data[0] = 10; //为数组赋值
data[1] = 20; //为数组赋值
data[2] = 30; //为数组赋值
int temp [] = data ; //引用操作, 只有声明的时候加上“[]”
temp[0] = 100; //修改内容
for(int x = 0 ; x<da ; x++){
Sy(data[x]+"、");
}
}
}
范例四内存分析：
三、数组与方法
既然数组内容可以进行引用传递,那么就可以把数组作为方法中的参数,而如果一个方法要想接收参数,则对应的参数类型必须是数组
1.使用方法接收数组
范例五：
public class TestDemo{
public static void main(String args[]){
int data[] = new int[] {209,201,2,2,3,6,7}; //静态初始化
print(data); //引用传递, 相当于int temp [] = data;
}
public static void print(int temp[]){ //接收数组
for (int x = 0 ; x < ; x++){ //循环输出
Sy(temp[x]+",");
}
}
}
范例五内存分析：
2.判断某一个数据是否在指定的数组之中（定义在方法实现）
范例六：
public class TestDemo{
public static void main(String args[]){
int data[] = new int[]{209,201,2,2,3,6,7};
int searchData = 3; //要查找的内容
if (isExists(data,searchData)){ //为true
Syln("已经查找到了内容");
}else{
Syln("没有找到内容");
}
}
public static boolean isExists(int temp [] ,int search){ //是否存在
for (int x = 0 ; x < ; x++){
if(temp[x] == search){
return true; //查找到了,循环结束
}
}
return false; //没有查找到
}
}
以上程序，只是完成了方法接收数组的操作，却并没有在方法中对数组的内容进行修改，而由于是引用传递，方法也可以对数组进行修改的。
在方法里修改数组的内容
范例七：
public class TestDemo{
public static void main(String args[]){
int data [] = new int []{1,2,3,4,5}; //5个元素
inc(data); //数组之中的每一个元素扩大两倍
print(data); //打印数组
}
public static void inc(int temp[]){ //接收数组
for (int x = 0 ;x< ; x++){
temp[x] *= 2; //扩大数据 ,相当于temp[x] = temp[x] * 2
}
}
public static void print(int temp[]){
for(int x = 0 ; x< ; x++){
Sy(temp[x]+",");
}
Syln();
}
}
范例七内存分析：
四、数组排序的操作（冒泡算法）
范例八：
public class TestDemo{
public static void main(String args[]){
int data [] = new int[] {1,3,2,6,10,0,5,8}; //原始数组
sort(data); //排序方法
print(data); //输出数组
}
public static void sort(int temp[]){
for(int x = 0 ; x<; x++){ //控制排序次数
for(int y = 0 ; y< -1 ; y++){ //排序数组,-1是防止数组超出范围
if(temp[y]>temp[y+1]){ //后面的数据小
int t = temp[y]; //交换数据
temp[y] = temp[y+1]; //交换数据
temp[y+1] = t; //交换数据
}
}
}
}
public static void print(int temp[]){
for(int x = 0 ; x< ;x++){
Sy(temp[x]+",");
}
Syln();
}
}
五、与数组相关的操作方法
1.数组排序：
可以按照由小到大的顺序对基本数据类型的数组(如 int数组、double数组都未基本类型数组)进行排序，操作语法为（java.u(数据名称)）
范例九：
//数组排序
public class TestDemo{
public static void main(String args[]){
int data[] = new int[]{1,3,2,6,10,0,5,8}; //定义数组
java.u(data); //数组排序
print(data);
}
public static void print(int temp[]){
for(int x :temp){
Sy(x+",");
}
}
}
2.数组拷贝:
从一个数组之中拷贝部分内容到另一个数组之中，方法为Sy(源数组名称,源数组开始点,目标数组名称,目标数组开始点,拷贝长度)
范例十：
//数组拷贝
public class TestDemo{
public static void main(String args[]){
int dataA[] = new int[]{1,2,3,4,5,6,7,8,9}; //数组1
int dataB[] = new int[]{11,22,33,44,55,66,77,88,99}; //数组2
Sy(dataB,5,dataA,2,3); //数组拷贝
print(dataA); //输出
}
public static void print(int temp[]){
for(int x = 0 ; x < ; x++){
Sy(temp[x]+",");
}
Syln();
}
}
六、二维数组
1.数组的定义格式如下：
动态初始化:
数据类型数据名称[][] = new数组名称[行数][列数];
int[][] arr = new int[3][5];---定义了一个整型的二维数组，其中包含3个一维数组，每个一维数组可以存储5个整数
arr[0];---下标为0的位置上的一维数组
arr[1][3];---如果要获取具体的元素需要两个下标
int[][] arr = new int[3][];----表示一个包含了3个整型的一维数组的二维数组（这句话好好理解）
静态初始化:
数据类型数据名称[][] = new数组名称[][]{{值,值,…},{值,值,…},{值,值,…},…}
int[][] arr = {{2,5},{1},{3,2,4},{1,7,5,9}};
注意：[]在变量名前的时候，是紧跟数据类型的；如果[]在后，则是属于当前变量名。
2.二维数组的应用
二维数组的长度：数组名.length
每个一维数组：数组名[下标].length
二维数组的遍历---两重for循环
for(int i = 0; i < arr.length; i++){ //遍历二维数组，遍历出来的每一个元素是一个一维数组
for(int j = 0; j < arr[i].length; j++){ //遍历对应位置上的一维数组
Syln(arr[i][j]);
}
}
二维数组的反转---头尾交换
for(int start = 0, end = arr.length -1; start < end; start++,end--){
int[] temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
七、对象数组（重点）
之前所讲解的全部数组，都属于基本数据类型的数组，但是如果现在想要表达出多个对象，那么就需要对象数组的概念，而对象数组的定义格式和之前是完全一样的，只要把数据类型换成类即可。
对象数组的动态初始化:
类名称对象数组名称= new类名称[长度];
范例十一：
//对象数组的动态初始化
class Person{
private String name;
private int age;
public Person(String n, int a){
name = n;
age = a;
}
public String getInfo(){
return "姓名:"+name+",年龄:"+age;
}
}
public class TestDemo{
public static void main(String args[]){
Person per[] = new Person[3]; //对象数组
per[0] = new Person("沐兮沐楚A",20); //实例化对象
per[1] = new Person("沐兮沐楚B",21); //实例化对象
per[2] = new Person("沐兮沐楚C",22); //实例化对象
for(int x = 0 ;x<;x++){ //循环输出
Syln(per[x].getInfo());
}
}
}
对象数组的静态初始化:
类名称对象数组名称= new类名称[]{实例化对象,实例化对象,…};
范例十二：
class Person{
private String name;
private int age;
public Person(String n,int a){
name = n;
age = a;
}
public String getInfo(){
return "姓名:"+name+",年龄:"+age;
}
}
public class TestDemo{
public static void main(String args[]){
Person per[] = new Person[]{
new Person("沐兮沐楚A",20),new Person("沐兮沐楚B",30),new Person("沐兮沐楚C",20)};//对象数组
for(int x = 0; x<; x++){ //循环输出
Syln(per[x].getInfo());
}
}
}
感谢大家的支持,你们的支持就是我的动力，如果对您有所帮助，请转发并收藏，谢谢！