概念：把数据码成一排进行存放。
代码：

  1. package com.company;
  3. public class Array<泛型> {
  4.     private 泛型[] data;
  5.     private int size;
  7.     public Array(int capacity){
  8.         data = (泛型[])new Object[capacity];
  9.         size = 0;
  10.     }
  12.     public Array(){
  13.         this(10);
  14.     }
  16.     //返回数组里的当前最大下标值
  17.     public int getSize(){
  18.         return size;
  19.     }
  20.     //返回数组内容个数
  21.     public int getCapacity(){
  22.         return data.length;
  23.     }
  24.     //判断数组是否为空
  25.     public boolean isEmpty(){
  26.         return size == 0;
  27.     }
  28.     //向末尾添加
  29.     public void addLast(泛型 e){
  30.         this.add(size, e);
  31.     }
  32.     //在第一位插入
  33.     public void addFirst(泛型 e){
  34.         add(0, e);
  35.     }
  36.     //在某一位插入
  37.     public void add(int index, 泛型 e){
  38.         if (size == data.length){
  39.             resize(2 * data.length);
  40.         }
  41.         if (index < 0 || index > size){
  42.             throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
  43.         }
  44.         for (int i = size-1; i>= index ;i--){
  45.             data[i+1] = data[i];
  46.         }
  47.         data[index] = e;
  48.         size++;
  49.     }
  50.     //获取index索引位置的元素
  51.     public 泛型 get(int index){
  52.         if (index<0 || index>=size){
  53.             throw new IllegalArgumentException("Get failed. Index is illegal");
  54.         }
  55.         return data[index];
  56.     }
  57.     //修改index索引位置的元素
  58.     public void set(int index,泛型 e){
  59.         if (index<0 || index>=size){
  60.             throw new IllegalArgumentException("Set failed. Index is illegal");
  61.         }
  62.         data[index] = e;
  63.     }
  64.     //查看数组中是否有元素e
  65.     public boolean contains(泛型 e){
  66.         for(泛型 i : data){
  67.             if (i.equals(e)){
  68.                 return true;
  69.             }
  70.         }
  71.         return false;
  72.     }
  73.     //查找数组中元素e所在索引，如果不存在元素e，则返回-1
  74.     public int find(泛型 e){
  75.         for (int i = 0 ; i<size ; i++){
  76.             if (data[i].equals(e)){
  77.                 return i;
  78.             }
  79.         }
  80.         return -1;
  81.     }
  82.     //从数组中删除index位置的元素，返回删除的元素
  83.     public 泛型 remove(int index){
  84.         if (index<0 || index>=size){
  85.             throw new IllegalArgumentException("Set failed. Index is illegal");
  86.         }
  87.         泛型 ret = data[index];
  88.         for (int i = index+1; i<size; i++){
  89.             data[i-1] = data[i];
  90.         }
  91.         size--;
  92.         //data[size] = null;
  93.         if (size == data.length / 4 && data.length /2 != 0){
  94.             resize(data.length / 2);
  95.         }
  96.         return ret;
  97.     }
  98.     //删除第一个元素，返回删除的元素
  99.     public 泛型 removeFirst(){
  100.         return remove(0);
  101.     }
  102.     //删除最后一个元素，返回删除的元素
  103.     public 泛型 removeLast(){
  104.         return remove(size-1);
  105.     }
  106.     //从数组中删除元素e
  107.     public void removeElement(泛型 e){
  108.         int index = find(e);
  109.         if (index != -1){
  110.             remove(index);
  111.         }
  112.     }
  114.     @Override
  115.     public String toString(){
  116.         StringBuilder res = new StringBuilder();
  117.         res.append(String.format("Array: size = %d , capacity = %d\n" ,size , data.length));
  118.         res.append('[');
  119.         for (int i = 0; i<size ;i++){
  120.             res.append(data[i]);
  121.             if (i != size-1){
  122.                 res.append("，");
  123.             }
  124.         }
  125.         res.append("]");
  126.         return res.toString();
  127.     }
  129.     private void resize(int newCapacity){
  130.         泛型[] newData = (泛型[]) new Object[newCapacity];
  131.         for (int i = 0; i<size; i++){
  132.             newData[i] = data[i];
  133.         }
  134.         data = newData;
  135.     }
  136. }
  1. package com.company;
  3. public class Main {
  5.     public static void main(String[] args) {
  6.         /*静态数组：
  7.         int[] arr = new int[10];
  8.         for (int i : arr)
  9.             System.out.println(i);
  11.         System.out.println("--------------------------------------");
  13.         int[] scores = new int[]{100, 99, 66};
  14.         for (int i : scores)
  15.             System.out.println(i);
  17.         System.out.println("-------------------------------------------");
  19.         scores[0] = 98;
  20.         for (int i : scores)
  21.             System.out.println(i);
  23.         System.out.println("-------------------------------------------");*/
  25.         //动态数组：
  26.         Array<Integer> arr2 = new Array<>();
  27.         for (int i=0; i<10; i++){
  28.             arr2.addLast(i);
  29.         }
  30.         System.out.println(arr2);
  32.         arr2.add(1, 100);
  33.         System.out.println(arr2);
  35.         arr2.remove(2);
  36.         arr2.removeElement(4);
  37.         arr2.removeElement(0);
  38.         System.out.println(arr2);
  39.     }
  40. }

一维数组

可以存放上千万个数据，并且这些数据类型是相同的。
声明数组格式：

  1. //方式一：
  2. int a[];
  3. a = new int[3];
  4. a[0] = 0;
  5. a[1] = 1;
  6. a[2] = 2;
  8. //方式二：
  9. int a[] = new int[3];
  10. a[0] = 0;
  11. a[1] = 1;
  12. a[2] = 2;
  14. //方式三：
  15. int a[] = {0 , 1, 2};

相关的API方法

拷贝

  1. public class ShuZuKaoBei {
  2.     public static void main(String[] args) {
  3.         int a1[] = {1,2,3,4,5};
  4.         int a2[] = {9,8,7,6,5,4,3};
  5.         System.arraycopy(a1, 0, a2, 0, 3);//执行数组拷贝的操作
  6.         System.out.print("a1数组中的内容：");
  7.         for (int a : a1) {
  8.             System.out.print(a + " ");
  9.         }
  10.         System.out.println();
  12.         System.out.print("a2数组中的内容：");
  13.         for (int a : a2) {
  14.             System.out.print(a + " ");
  15.         }
  16.         System.out.println("\n 数组拷贝完成！");
  17.     }
  18. }
  20. //输出内容：
  21. a1数组中的内容：1 2 3 4 5 
  22. a2数组中的内容：1 2 3 6 5 4 3 
  23.  数组拷贝完成！

System.arraycopy(source,0,dest,0,x)：
复制源数组从下标0开始的x个元素到目标数组，从目标数组的下标0所对应的位置开始存取。

排序

  1. public class ShuZuPaiXu{
  2.     public static void main(String[] args){
  3.         int a[] = {4,32,45,32,65,32,2};
  5.         System.out.print("数组排序前的顺序：");
  6.         for (int aa : a){
  7.             System.out.print(a + " ");
  8.         }
  9.         Arrays.sort(a);//数组的排序方法
  11.         System.out.print("\n 数组排序后的顺序");
  12.         for (int aa : a){
  13.             System.out.print(a + " ");
  14.         }
  15.     }
  16. }
  18. //输出内容：
  19. 数组排序前的顺序：4 32 45 32 65 32 2
  20. 数组排序后的顺序：2 4 32 32 32 45 65

Arrays.sort(数组名)：
数组的排序方法，在java.util包里，使用的时候需要先导入。