疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java基础数组操作


 

   

  数组是一种数据结构,用来存储同一类型值的集合。

  数组作为对象允许使用new关键字进行内存分配,在使用数组之前,必须首先定义数组变量所属的类型。

  数组通过一个整型下标可以访问数组中得每一个值,例如,如果存在数组a。则a[i]就是数组中下标为i的整数(下标从0开始)。

  1.数组的声明及初始化

  复制代码

  1      //声明

  2 int [] iArr ;

  3 String sArr [];

  4

  5 //声明并分配大小

  6 int [] iArr2 = new int[3]; //数组内默认值为0

  7 String [] sArr2 = new String[10];//数组默认值为null

  8 System.out.println(Arrays.toString(iArr2));//打印数组

  9 System.out.println(Arrays.toString(sArr2));

  10 /*输出

  11 * [0, 0, 0]

  12 [null, null, null, null, null, null, null, null, null, null]

  13 */

  14

  15 //声明并赋值

  16 int [] iArr3 = new int[]{2,3,4,6};

  17 String [] sArr3 = {"ONE","TWO","THREE"};

  18 System.out.println(Arrays.toString(iArr3));//[2, 3, 4, 6]

  19 System.out.println(Arrays.toString(sArr3));//[ONE, TWO, THREE]

  20

  21 //简单使用

  22 iArr = new int[]{1,2,3};

  23 sArr = new String[2];

  24 sArr[0] = "hello";

  25 sArr[1] = "friend";

  26 System.out.println(iArr[1]);//2

  27 System.out.println(Arrays.toString(sArr));//[hello, friend]

  复制代码

  2.数组的操作

  (1)数组的遍历

  复制代码

  //数组的遍历

  int[] arr = {2,4,5,9,7};

  for(int i = 0; i < arr.length; i++){

  System.out.print(arr[i]+" ");//2 4 5 9 7

  }

  System.out.println();

  for(int num : arr){

  System.out.print(num+" ");//2 4 5 9 7

  }

  复制代码

  (2)数组的填充

  Arrays.fill()方法能够对数组进行填充,fill()方法有很多重载的方法,能够满足任意数组元素的填充或者替换。

  复制代码

  int[] arr = new int[5];

  //填充

  Arrays.fill(arr, 6);

  System.out.println(Arrays.toString(arr));//[6, 6, 6, 6, 6]

  //替换

  Arrays.fill(arr,2,4,0);

  System.out.println(Arrays.toString(arr));//[6, 6, 0, 0, 6]

  复制代码

  (3)数组的排序

  Arrays.sort()方法能够对数组进行排序

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

  Arrays.sort(arr);

  System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]

  (4)数组的复制

  Arrays类中copyOf()方法和copyOfRange()方法可以实现对数组的复制,

  前者是复制数组到指定长度,后者是将指定长度的数组复制到一个新的数组中(或者覆盖之前的数组)。

  coypOf(arr, int newLength) 可用于数组的扩容

  -arr: 要进行复制的数组

  -newLength: 复制后数组的长度,如果新数组复制的长度大于arr,则用0或者null补充。如果新数组小于arr的长度,则复制arr的0为开始直至满足数组的长度。

  int[] arr = new int[]{3,4,5};

  arr = Arrays.copyOf(arr, arr.length*2);

  System.out.println(Arrays.toString(arr));//[3, 4, 5, 0, 0, 0]

  int[] newArr = Arrays.copyOf(arr, 2);

  System.out.println(Arrays.toString(newArr));//[3, 4]

  copyOfRange(arr, int fromIndex, int toIndex)

  -arr: 要复制的数组

  -fromIndex:指定要复制数组的开始索引位置,不能大于arr的长度

  -toIndex:指定要复制数组的最后索引位置(不包括toIndex) 可以大于arr的长度

  int[] arr = {5, 7, 8, 2, 9};

  arr = Arrays.copyOfRange(arr, 0, arr.length*2);

  System.out.println(Arrays.toString(arr));//[5, 7, 8, 2, 9, 0, 0, 0, 0, 0]

  int[] newArr = Arrays.copyOfRange(arr, 1, 3);

  System.out.println(Arrays.toString(newArr));//[7, 8]

  在System类中的arraycopy方法将数组的元素copy到另一个数组中,方法为:

  System.arraycopy(src, srcPos, dest, destPos, length)

  -src: 要复制的数组

  -srcPos:将要复制的数组的索引位置

  -dest: 目标数组

  -destPos:目标数组的索引位置

  -length:要复制的长度,从索引位置开始计数

  int[] arr = {6, 4, 11, 12};

  int [] newArr = new int[]{5,4,9,3,4,2};

  System.arraycopy(arr, 2, newArr, 0, 2);

  System.out.println(Arrays.toString(newArr));//[11, 12, 9, 3, 4, 2]

  3.数组的排序

  (1) 冒泡排序

  冒泡的基本思路是对比相邻的元素值,如果满足条件就交换元素值,把较小的元素移动到数组前面,把大的元素移动到数组后面。

  复制代码

  //冒泡排序

  int[] arr = new int[]{12, 3, 65, 45, 88, 1, 7};

  for(int i = 0; i < arr.length -1; i++){

  for(int j = 0; j < arr.length - 1 - i; j++){

  if(arr[j] > arr[j+1]){

  int temp = arr[j];

  arr[j] = arr[j+1];

  arr[j+1] = temp;

  }

  }

  }

  System.out.println(Arrays.toString(arr));//[1, 3, 7, 12, 45, 65, 88]

  复制代码

  (2)直接选择排序

  直接选择排序的思路是将指定排序位置与其他数组元素分别对比,如果满足条件就交换元素,找出最大数后与“最后”一个元素交换。

  复制代码

  //直接选择排序

  int[] arr = new int[]{12, 3, 65, 45, 88, 1, 7};

  int index;

  for(int i = 1; i < arr.length; i++){

  index =0;

  //找出最大值

  for(int j = 0; j <= arr.length - i; j++){

  if(arr[j] > arr[index]){

  index = j;

  }

  }

  //最大值放到最后的位置上

  int temp = arr[index];

  arr[index] = arr[arr.length - i];

  arr[arr.length - i] = temp;

  }

  System.out.println(Arrays.toString(arr));//[1, 3, 7, 12, 45, 65, 88]

  复制代码

  (3)反转排序

  将数组的元素反转替换,即将元素的最后一个元素与第一个元素进行交换,倒数第二个元素与数组的第二个元素进行交换。。。。

  复制代码

  //翻转排序 -将数组的位置反过来

  int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7};

  int arrLength = arr.length;

  for(int i = 0; i < arrLength/2 ; i++ ){

  int temp = arr[i];

  arr[i] = arr[arrLength-1-i];

  arr[arrLength-1-i] = temp;

  }

  System.out.println(Arrays.toString(arr));//[7, 6, 5, 4, 3, 2, 1]