Java 数组

最新推荐文章于 2024-08-09 07:30:00 发布

程序员学习圈

最新推荐文章于 2024-08-09 07:30:00 发布

阅读量218

点赞数

分类专栏： # Java SE

本文链接：https://blog.csdn.net/Luomingkui1109/article/details/79763949

版权

Java SE 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

1.数组

用于批量保存一类数据，是引用数据类型之一。

2.数组的默认值

(1) 基本数据类型：

byte short int ----> 0

long ----> 0L

float ----> 0.0F

double ----> 0.0D

char ----> '\u0000'

boolean ----> false

(2) 引用数据类型：

类(class)

接口(interface)

数组([])

3. 一维数组

(1) 声明一个数组

int[] scores;  // 首选的方法
或者
String names[];   // 效果相同，但不是首选方法
说明：Java语言中声明数组时不能指定其长度(数组中元素的数)。例如： int a[5];    //非法

(2) 为数组初始化

① 静态初始化：初始化操作和赋值操作同时进行

int[] scores = new int[]{1,2,3,4,5};

② 动态初始化 : 初始化操作和赋值操作分开进行

String[] names = new String[5];

names[0] = "张三";

names[2] = "李四";

(3) 遍历获取数组元素

① 使用普通 for 循环

for(int i = 0; i < names.length; i++){
     System.out.println(names[i]);
}

② 使用增强 for 循环 //JDK 1.5 引进了一种新的循环类型，被称为 foreach 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

for(String str : names){
     System.out.println(str);
}

(4) 注意

① 无论静态初始化还是动态初始化必须指明长度

② 获取数组长度的属性： length

③ 数组中每个元素的位置都有索引值(下角标、下标) ，索引值从0开始，到数组的长度 - 1·

(5) 实例1

public class TestArray {
    public static void main(String[] args) {
        //基本数据类型
        int[] a = new int[]{1,3,5,7,9,10};
        //
        for(int i=0;i<a.length;i++){
           System.out.println(a[i]);
        }
        for(int str : a){
            System.out.println(str);
        }
        //引用数据类型
        String[] names = new String[5];
        names[0] = "张三";
        names[2] = "李四";
        for(int i = 0; i < names.length; i++){
            System.out.println(names[i]);
        }
        for(String str : names){
            System.out.println(str);
        }
    }
}

(6) 实例2

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);
   }
}

4.二维数组

(1) 声明一个二维数组

int[][] arr;

(2) 为二维数组初始化

①静态初始化 ：
        int[][]  arr = new int[][]{ {1,2,3}, {4,5,6}, {7,8} };
②动态初始化
        arr = new int[5][];
        arr[1][1] = 15;
        arr[3][4] = 22;

(3) 使用循环遍历数组元素

① 使用普通 for 循环

for(int i = 0; i < arr.length; i++){
     for(int j = 0; j < arr[i].length; j++){
         System.out.print(arr[i][j] + "\t");
     }
         System.out.println();
}

② 使用增强 for 循环

for(int[] as : arr){
     for(int a : as){
          System.out.print(a + "\t");
     }
     System.out.println();
}

5.Array类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

给数组赋值：通过 fill 方法。

对数组排序：通过 sort 方法,按升序。

比较数组：通过 equals 方法比较数组中元素值是否相等。

查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-( 插入点 ) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

6.数组属性：

(1) 数组的查询

public static void main (String []args){
             int a[] = new int[] {1, 3, 4, 6, 8, 9};
             int x1 = Arrays.binarySearch(a, 5);
             int x2 = Arrays.binarySearch(a, 4);
             int x3 = Arrays.binarySearch(a, 0);
             int x4 = Arrays.binarySearch(a, 10);
             System.out.println("x1:" + x1 + ", x2:" + x2);
             System.out.println("x3:" + x3 + ", x4:" + x4);
 }

(2) 数组的比较

public class TestArray {
    public static void main(String[] args) {
        int arr[] = new int [] {12,85,60,100};
        Arrays.sort(arr);   //升序
        int abc[]=Arrays.copyOf(arr ,2);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        for(int i=0;i<abc.length;i++){
            System.out.println(arr[i]);
        }
        System.out.println(arr.equals(abc));
    }
}

(3) 数组的排序

public static void main(String[] args) {
       int arr[] = new int [] {12,85,60,100};
       Arrays.sort(arr);   //升序
       for(int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
      }
}
说明：Java类型的数组排序算法是根据字典排序的，因此，数字在字母前面，大写在小写字母前面。

(4) 数组的复制

数组容量如果不够用可以使用 Arrays.copyOf() 进行扩容：

Array.copy(E[] e,newLength);

其第一个形参指的是需要扩容的数组，后面是扩容后的大小，其内部实现其实是使用了 System.arrayCopy(); 在内部重新创建一个长度为 newLength 类型是 E 的数组。

import java.util.Arrays;  
public class Main {
    public static void main(String[] args) {
        int[] a= {10,20,30,40,50};
        a= Arrays.copyOf(a,a.length+1);
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]);
        }
    }
}
//默认补 0，输出结果为： 10 20 30 40 50 0

(5) 检查数组中是否包含某值

Arrays.asList() 将一个数组转化为一个List对象，这个方法会返回一个ArrayList类型的对象，这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

public static void main(String[] args) {
      String[] arr= { "a", "b", "c", "d", "e" };
      boolean b = Arrays.asList(arr).contains("a");
      System.out.println(b);
}

(6) 连接两个数组

方法一：

public static void main(String[] args) {
   String[] oneArray = getOneArray();
   for (String string : oneArray) {
        System.out.println(string);
     }
}

public static String[] getOneArray() {
     String[] a = { "0", "1", "2" };
     String[] b = { "0", "1", "2" };
     String[] c = new String[a.length + b.length];
     for (int j = 0; j < a.length; ++j) {
      c[j] = a[j];
     }
     for (int j = 0; j < b.length; ++j) {
      c[a.length + j] = b[j];
     }

     return c;
}

方法二：

public static void main(String[] args) {
         Object[] twoArray = getTwoArray();
         for (Object object : twoArray) {
              System.out.println(object);
         }
     }
      public static Object[] getTwoArray() {
           String[] a = { "0", "1", "2" };
           String[] b = { "0", "1", "2" };
           List<String> aL = Arrays.asList(a);
           List<String> bL = Arrays.asList(b);
           List<String> resultList = new ArrayList<String>();
           resultList.addAll(aL);
           resultList.addAll(bL);
           Object[] result = resultList.toArray();
           return result;
      }

方法三：

public static void main(String[] args) {
         int[] intArray = { 1, 2, 3, 4, 5 };
         int[] intArray2 = { 6, 7, 8, 9, 10 };
         // Apache Commons Lang library
         int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);
         for (int i : combinedIntArray) {
              System.out.println(i);
         }
}

(6) 逆向输出一个数组

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("\n");
        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;
    }
}

(7) 移除数组中的元素(ArrayUtils 工具类在用的时候需要导入相关的jar包： org.apache.commons.lang.ArrayUtils )

public static void main(String[] args) {
      int[] arr= { 1, 2, 3, 4, 5 };
      int[] removed = ArrayUtils.removeElement(arr, 3);//create a new array
      System.out.println(Arrays.toString(removed));
 }