数组的基本定义

如果说现在要定义100个整型变量.那么按照传统的做法,现在的实现如下：

int i1,i2,i3…………i100;

这种方式不利于维护.

Java中数组定义为引用数据类型

数组的动态初始化
- 声明并初始化
  - 数据类型数组名称 []=new 数据类型[长度]
  - 数据类型 [] 数组名称 =new 数据类型[长度]
数组的静态初始化
- 简化格式
  - 数据类型数组名称[] ={数据1，数据2，数据3}
- 完整格式
  - 数据类型数组名称[] =new 数据类型[]{数据1，数据2，数据3}

/*数组的动态初始化
声明并初始化
数据类型 数组名称 []=new 数据类型[长度]
数据类型 [] 数组名称 =new 数据类型[长度]
数组的静态初始化
简化格式
数据类型 数组名称[] ={数据1，数据2，数据3}
完整格式
数据类型 数组名称[] =new 数据类型[]{数据1，数据2，数据3}*/
public class ArrayDemo {
  public static void main(String[] args) {
    int data[] = new int[3]; // 数组的动态初始化
    int[] date = new int[3]; // 数组的动态初始化

    String color[] = {"red", "blue"}; // 数组的静态初始化
    int num[] = new int[] {1, 2, 3}; // 数组的静态初始化
    for (int i = 0; i < num.length; i++) {
      System.out.println(num[i]);
    }
  }
}

数组引用传递分析

在数组的使用过程中发现,需要关键字new进行内存空间的开辟

public class ArrayDemo2 {
  public static void main(String[] args) {
    int data[] = new int[] {10, 20, 30};
    int temp[] = data;
    temp[0] = 99;
    for (int i = 0; i < data.length; i++) {
      System.out.println(data[i]);
    }
  }
}

数组本身属于引用数据类型,一定会发生引用传递

一个堆内存可以被多个栈内存所指向

foreach输出

for(数据类型变量:数组|集合)｛｝

最大的特地在于可以自动将数组中每一个元素取出保存在变量里面,这样避免了下标

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

二维数组

传统数组好比一行数据、

下标	0	1
数据	10	20

下标	0	1	2
0	10	20	30
1	30	20	10
2	10	20	30

对于二维数组,定义的语法如下:

数组的动态初始化
- 数据类型数组名称 [][]=new数据类型[行数][列数]
数组的静态初始化
- 数据类型数组名称 [][]=new数据类型[][]｛{数据1，数据2}，{数据1，数据2}，{数据1，数据2}｝

public class ArrayDemo3 {
  public static void main(String[] args) {
    int data[][] = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    for (int[] temp : data) {
      for (int num : temp) {
        System.out.print(num + "、");
      }
      System.out.println();
    }
  }
}

数组与方法

对于引用数据类型而言,主要的特点是可以与方法进行引用传递,数组本身也属于引用数据类型,所以同样夜可以通过方法实现引用传递

/** 实现一个数组的引用传递 */
public class ArrayDemo4 {
  public static void main(String[] args) {
    int data[] = new int[] {1, 2, 3, 4, 5};
    printArray(data);
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

/** 实现返回一个数组 */
public class ArrayDemo5 {
  public static void main(String[] args) {
    int data[] = initArray();
    printArray(data);
  }

  public static int[] initArray() {
    int arr[] = new int[] {1, 2, 3, 4, 5};
    return arr;
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

/** 通过方法修改数组内容 */
public class ArrayDemo6 {
  public static void main(String[] args) {
    int data[] = initArray();
    printArray(data);
    changeArray(data);
    System.out.println("*****修改后*****");
    printArray(data);
  }

  public static void changeArray(int arr[]) {
    for (int i = 0; i < arr.length; i++) {
      arr[i] *= 2;
    }
  }

  public static int[] initArray() {
    int arr[] = new int[] {1, 2, 3, 4, 5};
    return arr;
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

/** 定义一个int数组,要求可以计算这个数组的总和，最大值,最小值，平均值 */
public class ArrayDemo7 {
  public static void main(String[] args) {
    int[] arr = new int[] {1, 2, 3, 4};
    System.out.println("总和为:" + sumArray(arr));
    System.out.println("最大值为:" + maxArray(arr));
    System.out.println("最小值为:" + minArray(arr));
    System.out.println("平均值为:" + avgArray(arr));
  }

  public static int sumArray(int arr[]) {
    int sum = 0;
    for (int temp : arr) {
      sum += temp;
    }
    return sum;
  }

  public static int maxArray(int arr[]) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
      if (arr[i] > max) {
        max = arr[i];
      }
    }
    return max;
  }

  public static int minArray(int arr[]) {
    int min = arr[0];
    for (int i = 1; i < arr.length; i++) {
      if (arr[i] < min) {
        min = arr[i];
      }
    }
    return min;
  }

  public static double avgArray(int arr[]) {
    double avg = 0.0;
    avg = sumArray(arr) / arr.length;
    return avg;
  }
}

class ArrayUtil {
  private int sum;
  private int max;
  private int min;
  private double avg;

  public ArrayUtil(int arr[]) {
    this.sum = 0;
    this.max = arr[0];
    this.min = arr[0];
    for (int i = 0; i < arr.length; i++) {
      if (arr[i] > max) {
        this.max = arr[i];
      }
      if (arr[i] < min) {
        this.min = arr[i];
      }
      this.sum = sum + arr[i];
    }

    this.avg = this.sum / arr.length;
  }

  public int getSum() {
    return this.sum;
  }

  public int getMax() {
    return this.max;
  }

  public int getMin() {
    return this.min;
  }

  public double getAvg() {
    return this.avg;
  }
}

public class ArrayDemo8 {
  public static void main(String[] args) {
    int[] arr = new int[] {1, 2, 3, 4};
    ArrayUtil array = new ArrayUtil(arr);
    System.out.println("总和为:" + array.getSum());
    System.out.println("最大值为:" + array.getMax());
    System.out.println("最小值为:" + array.getMin());
    System.out.println("平均值为:" + array.getAvg());
  }
}

数组排序案例分析

// 升序排序分析
public class ArrorderDemo {
  public static void main(String[] args) {
    int[] data = new int[] {7, 1, 0, 8, 2, 5, 10, 4, 9, 3, 6};
    for (int x = 0; x < data.length; x++) {
      for (int i = 0; i < data.length - x - 1; i++) {
        if (data[i] > data[i + 1]) {
          int temp = data[i];
          data[i] = data[i + 1];
          data[i + 1] = temp;
        }
      }
    }
    printArray(data);
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

class ArrayOrder {
  public static void sort(int[] data) {
    for (int x = 0; x < data.length; x++) {
      for (int i = 0; i < data.length - x - 1; i++) {
        if (data[i] > data[i + 1]) {
          int temp = data[i];
          data[i] = data[i + 1];
          data[i + 1] = temp;
        }
      }
    }
  }
}

public class OrderArray {
  public static void main(String[] args) {
    int[] data = new int[] {7, 1, 0, 8, 2, 5, 10, 4, 9, 3, 6};
    ArrayOrder.sort(data);
    printArray(data);
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

数组转置案例分析

数组的反转操作指的是进行前后转置处理

public class ArrayExchangeDemo {
  public static void main(String[] args) {
    int[] data = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int[] temp = new int[data.length];
    int foot = temp.length - 1;
    for (int i = 0; i < data.length; i++) {
      temp[foot--] = data[i];
    }
    data = temp;
    printArray(data);
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

这种做法产生了垃圾

public class ArrayExchangeDemo2 {
  public static void main(String[] args) {
    int[] data = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int center = data.length / 2; // 确定转化的次数
    int head = 0; // 操作的角标
    int tail = data.length - 1; // 操作的角标
    for (int i = 0; i < center; i++) {
      int temp = data[head];
      data[head] = data[tail];
      data[tail] = temp;
      head++;
      tail--;
    }
    printArray(data);
  }

  public static void printArray(int temp[]) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

数组相关库表

Java语言本身提供了相关的数据处理

1.数组排序:java.util.Arrays.srot(数组名称)

public class SortDemo {
  public static void main(String[] args) {
    int data[] = new int[] {5, 3, 4, 1, 2};
    java.util.Arrays.sort(data);
    printArray(data);
  }

  public static void printArray(int[] temp) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

2.数据拷贝: System.arraycopy(源数组，源数组开始点，目标数组，目标数组开始点，拷贝长度)

public class CopyDemo {
  public static void main(String[] args) {
    int[] data1 = new int[] {1, 2, 3, 4, 5};
    int[] data2 = new int[data1.length];
    System.arraycopy(data1, 1, data2, 1, 3);
    printArray(data2);
  }

  public static void printArray(int[] temp) {
    for (int tmp : temp) {
      System.out.println(tmp);
    }
  }
}

方法可变参数

定义一个方法,实现任意多个整型数据的相加处理

class ArraySum {
  public static int sum(int... data) {
    int sum = 0;
    for (int tmp : data) {
      sum += tmp;
    }
    return sum;
  }
}

public class SumArrayDemo {
  public static void main(String[] args) {
    System.out.println(ArraySum.sum(1, 2, 3, 4));
    System.out.println(ArraySum.sum(new int[] {1, 2, 3}));
  }
}

对象数组

Java程序本身各种数据类型都能成为数组,类也可以成为数组类型,这样的数组叫做对象数组

动态初始化
- 类对象数组名[]=new 类[长度] 每一个元素都是null
静态初始化
- 类对象数组名[]=new 类[]{实例化对象，实例化对象｝

class ObjectArray {
  private String name;
  private int age;

  public ObjectArray(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getInfo() {
    return "姓名" + this.name + "年龄" + this.age;
  }
}

class ObjectArrayDemo {
  public static void main(String[] args) {
    ObjectArray per[] = new ObjectArray[3];
    per[0] = new ObjectArray("张三", 23);
    per[1] = new ObjectArray("李四", 24);
    per[2] = new ObjectArray("王五", 25);
    for (int i = 0; i < per.length; i++) {
      System.out.println(per[i].getInfo());
    }
  }
}

public class ObjectArrayDemo2 {
  public static void main(String[] args) {
    ObjectArray per[] =
        new ObjectArray[] {
          new ObjectArray("张三", 20), new ObjectArray("李四", 21), new ObjectArray("王五", 22)
        };
    for (int i = 0; i < per.length; i++) {
      System.out.println(per[i].getInfo());
    }
  }
}

数组的定义与使用