数组 Array-java

Java 数组

重要的数据结构之一，用来存储固定大小的同类型元素

• 数组声明
• 创建数组
• 处理数组
• for-each
• 数组作为函数的参数
• 数组作为函数的返回值
• 多维数组
• Arrays类

数组声明

语法格式：

dataType[] arrayRefvar;//首选方法
//或者
dataType arrayRefVar[];

创建数组

通过new来创建数组
arrayRefVar = new dataType[arraySize];

• dataType[arraysize]创建了一个数组
• 把新创建的数组引用赋值给变量arrayRefVar

声明和创建一条语句完成
dataType[] arrayRefVar = new dataType[arraySize]

或者

dataType[] arrayRefVar = {value0,value1,value2...};

数组元素通过下标索引访问的。

示例：包含十个double数据类型元素的数组

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

处理数组

数组元素的类型和数组大小都是确定的，通常使用for-each循环

示例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

for-each

---

jdk1.5引进的一种新的循环类型，被成为for-each循环或增强for循环，可以不通过下标遍历数组。
语法格式：

for(type element:array){
    System.out.println(element);
}

示例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

数组作为函数的参数

---

示例

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

数组作为函数的返回值

示例

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];

  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

多维数组

---

即是数组的数组。

多维数组动态初始化
语法格式：type[] typeName = new type[typeLength1][typeLength2];

type可以是基本数据类型和复合数据类型
例如：int a[][] = new int[3][2];
多维数组的引用
语法格式：arryName[index0][index1]

例如：num[1][2];

Arrays类

可以更方便的操作数组，提供的方法都是静态的

• 给数组赋值：fill方法
• 数组排序：sort方法，升序
• 比较数组：通过equals方法比较数组中元素值是否相等
• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分法操作

编号	方法说明
1	public static binarySearch(Object[] a ,Object key) 用二分法查找，数组使用前必须是排序好的，在数组中返回下标
2	public static boolean equals(Long[] a, Long[] a2) 指定两个类型相同的数组，如果包含同等数量元素，并且所有元素都是对等的，则是真
3	public static void fill(int[] a,int val) 将指定的int值分配给指定int类型数组指定范围中的每个元素。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列

练习案例
1. 倒序练习

public class Test2 {
    public static void main(String[] args){
        int[] test= {1,2,4,5,7};
        for (int i : test) {
            System.out.print(i+" ");
        }
        System.out.println("
");
        test = Test2.reverse(test);
        for (int i : test) {
            System.out.print(i+" ");
        }
    }

    public static int[] reverse(int[] arr){
        int[] result = new int[arr.length];
        for (int i = 0,j=result.length-1; i < arr.length; i++,j--) {
            result[j] = arr[i];
        }
        return result;
    }
}

2. 数组和字符串的转换

public class Test {
    public static void main(String args[]) {
        String str = "helloworld";
        char[] data = str.toCharArray();// 将字符串转为数组
        for (int x = 0; x < data.length; x++) {
            System.out.print(data[x] + "  ");
            data[x] -= 32;
            System.out.print(data[x] + "  ");
        }
        System.out.println(new String(data));
    }
}

3. 冒泡排序

public class BubbleSort {
/**
 * N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。
 * @param args
 */
    public static void main(String[] args) {
        int arr[] = {26,15,29,66,99,88,36,77,111,1,6,8,8};
       
        for(int i=0;i < arr.length-1;i++) {//外层循环控制排序趟数
            for(int j=0; j< arr.length-i-1;j++) {
                        //内层循环控制每一趟排序多少次
                // 把小的值交换到前面
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }

            System.out.print("第"+(i+1)+"次排序结果：");
                                //列举每次排序的数据
            for(int a=0;a<arr.length;a++) {
                System.out.print(arr[a] + "	");
            }
            System.out.println("");
        }
        System.out.println("最终排序结果：");
        for(int a = 0; a < arr.length;a++) {
            System.out.println(arr[a] + "	");
        }
    }
}

4. 选择排序

public class Start
{
    public static void main(String[] args)
    {
        int[] arr={20,60,51,81,285,12,165,51,81,318,186,9,70};
        for(int a:arr)
        {
            System.out.print(a+" ");
        }

        System.out.println("
"+"---------------从小到大---------------");

        arr=toSmall(arr);
        for(int a:arr)
        {
            System.out.print(a+" ");
        }

        System.out.println("
"+"---------------从大到小---------------");

        arr=toBig(arr);
        for(int a:arr)
        {
            System.out.print(a+" ");
        }
    }
//    从大到小
    public static int[] toSmall(int[] arr)
    {
//遍历数组里除最后一个的其他所有数，因为最后的对象没有与之可以相比较的数
        for(int i=0;i<arr.length-1;i++)
        {
/*遍历数组里没有排序的所有数，并与上一个数进行比较
 *“k=i+1”因为自身一定等于自身，所以相比没有意义
 *而前面已经排好序的数，在比较也没有意义
 */
            for(int k=i+1;k<arr.length;k++)
            {
                if(arr[k]<arr[i])//交换条件（排序条件）
                {
                    int number=arr[i];
                    arr[i]=arr[k];
                    arr[k]=number;
                }//交换
            }
        }
        return arr;
    }
//    从小到大
//和前面一样
    public static int[] toBig(int[] arr)
    {
        for(int i=0;i<arr.length-1;i++)
        {
            for(int k=i+1;k<arr.length;k++)
            {
                if(arr[k]>arr[i])
                {
                    int number=arr[i];
                    arr[i]=arr[k];
                    arr[k]=number;
                }
            }
        }
        return arr;
    }
}

arrays方法使用

import java.util.Arrays;

public class TestArrays {
    public static void output(int[] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + " ");
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] array = new int[5];
        // 填充数组
        Arrays.fill(array, 5);
        System.out.println("填充数组：Arrays.fill(array, 5)：");
        TestArrays.output(array);
        // 将数组的第2和第3个元素赋值为8
        Arrays.fill(array, 2, 4, 8);
        System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
        TestArrays.output(array);
        int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
        // 对数组的第2个到第6个进行排序进行排序
        Arrays.sort(array1, 2, 7);
        System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
        TestArrays.output(array1);
        // 对整个数组进行排序
        Arrays.sort(array1);
        System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
        TestArrays.output(array1);
        // 比较数组元素是否相等
        System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "
" + Arrays.equals(array, array1));
        int[] array2 = array1.clone();
        System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "
" + Arrays.equals(array1, array2));
        // 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
        Arrays.sort(array1);
        System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "
" + Arrays.binarySearch(array1, 3));
        // 如果不存在就返回负数
        System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "
" + Arrays.binarySearch(array1, 9));
    }
}