Java实例——数组

最新推荐文章于 2024-05-09 22:50:16 发布

Zain_horse

最新推荐文章于 2024-05-09 22:50:16 发布

阅读量529

点赞数

分类专栏： Java 文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/Zain_horse/article/details/129050808

版权

Java 专栏收录该内容

45 篇文章 2 订阅

订阅专栏

文章详细介绍了Java中对数组的各种操作，包括使用Arrays.sort()进行排序，二分查找binarySearch()，插入元素insertElement()，翻转数组Collections.reverse()，获取数组长度，最大最小值获取，以及数组的交集、差集和并集计算。同时，文章还展示了如何将数组转换为List并进行相关操作，如删除元素和判断相等性。

摘要由CSDN通过智能技术生成

1、数组排序及元素查找
数组排序 sort();Collection.reserveOrder();
元素查找 binarySearch()

import java.util.Arrays;

public class MainClass {
   public static void main(String args[]) throws Exception {
      int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
      Arrays.sort(array); //默认从小到大排序
      printArray("数组排序结果为", array);
      int index = Arrays.binarySearch(array, 2); //二分查找
      System.out.println("元素 2  在第 " + index + " 个位置");
   }
   
   private static void printArray(String message, int array[]) {
      System.out.println(message
      + ": [length: " + array.length + "]");
      for (int i = 0; i < array.length; i++) {
         if(i != 0){
            System.out.print(", ");
         }
         System.out.print(array[i]);                     
      }
      System.out.println();
   }
}

输出结果

数组排序结果为: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8
元素 2 在第 5 个位置

我们可以看到这里的sort()方法实现的是升序排列
那么我们可以想到一个问题，如何实现倒序排列

public static void main(String[] args) {
    Integer[] a = { 9, 8, 7, 2, 3, 4, 1, 0, 6, 5 };    // 数组类型为Integer
    Arrays.sort(a, Collections.reverseOrder());
    for (int arr : a) {
        System.out.print(arr + " ");
    }
}

输出结果

9 8 7 6 5 4 3 2 1 0

2、插入数组
insertElement(T[] arrays,T newElement,int index)

	public static void main(String args[]) throws Exception {
      int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
      Arrays.sort(array);
      printArray("数组排序", array);
      int index = Arrays.binarySearch(array, 1);
      System.out.println("元素 1 所在位置（负数为不存在）："
      + index);  
      int newIndex = -index - 1;
      array = insertElement(array, 1, newIndex);
      printArray("数组添加元素 1", array);
   }
   private static void printArray(String message, int array[]) {
      System.out.println(message
      + ": [length: " + array.length + "]");
      for (int i = 0; i < array.length; i++) {
         if (i != 0){
            System.out.print(", ");
         }
         System.out.print(array[i]);         
      }
      System.out.println();
   }
   private static int[] insertElement(int original[],
   int element, int index) {
      int length = original.length;
      int destination[] = new int[length + 1];
      System.arraycopy(original, 0, destination, 0, index);
      destination[index] = element;
      System.arraycopy(original, index, destination, index
      + 1, length - index);
      return destination;
   }

结果输出

数组排序: [length: 10] -9, -7, -3, -2, 0, 2, 4, 5, 6, 8 
元素 1 所在位置（负数为不存在）：-6 
数组添加元素 1: [length: 11] -9, -7, -3, -2, 0, 1, 2, 4, 5, 6, 8

3、获取数组长度
int length()

int[] arrays = new int[10];
System.out.println(arrays.length);

输出结果

4、数组翻转
Collection.reserve(T[] arrays);

 		ArrayList<Integer> arrays = new ArrayList<>();
        arrays.add(67);
        arrays.add(23);
        arrays.add(43);
        arrays.add(123);
        arrays.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        for (int a :arrays) {
            System.out.print(a+" ");
        }
        System.out.println();
        Collections.reverse(arrays);
        for (int a:arrays){
            System.out.print(a+" ");
        }

输出结果

升序：23 43 67 123 
降序：123 67 43 23

5、数组输出
数组的输出通常使用foreach迭代器输出

        ArrayList<Integer> arrays = new ArrayList<>();
        arrays.add(67);
        arrays.add(23);
        arrays.add(43);
        arrays.add(123);
        for (int a :arrays) {
            System.out.println(a);
        }

输出结果

6、数组最大最小值获取
Collections.max(ArrayList arrays)
Collections.min(ArrayList arrays)

      Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
      int min = (int) Collections.min(Arrays.asList(numbers));
      int max = (int) Collections.max(Arrays.asList(numbers));
      System.out.println("最小值: " + min);
      System.out.println("最大值: " + max);

输出结果

最小值: 1
最大值: 9

7、数组合并
使用List的[addAll() | add()] , toArray()进行数组合并

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
   public static void main(String args[]) {
      String a[] = { "A", "E", "I" };
      String b[] = { "O", "U" };
      List list = new ArrayList(Arrays.asList(a));
      list.addAll(Arrays.asList(b));
      Object[] c = list.toArray();
      System.out.println(Arrays.toString(c));
   }
}

输出结果

[A, E, I, O, U]

8、数组填充
Arrays.fill(T[] arrays,T object);
Arrays.fill(T[] arrays,int start,int end,T object)

int array[] = new int[6];
      Arrays.fill(array, 100); //以100填充array
      for (int i=0, n=array.length; i < n; i++) {
         System.out.println(array[i]);
      }
      System.out.println();
      Arrays.fill(array, 3, 6, 50);  //array从3位置至6位置填充50
      for (int i=0, n=array.length; i< n; i++) {
         System.out.println(array[i]);
      }

输出结果

9、数组扩容
System.arraycopy(T[] oldArray,int posIndex,T[] targetArray,int insertIndex,copyLength)
实际上就是重新申请一个数组空间，然后复制粘贴到新数组里

        String[] names = new String[] { "A", "B", "C" };
        String[] extended = new String[5];
        extended[0] = "D";
        extended[1] = "E";
        System.arraycopy(names, 0, extended, 2, names.length);
        for (String str : extended){
            System.out.println(str);
        }

D
E
A
B
C

10、删除数组元素
我们知道数组删除元素的效率很低，那么我们为什么不能用List的remove()呢？

		String[] str = new String[]{"第 0 个元素","第 1 个元素","第 2 个元素"};
        ArrayList objArray = new ArrayList();
        objArray.addAll(Arrays.asList(str));
        System.out.println("数组删除元素前："+objArray);
        objArray.remove(1);
        System.out.println("数组删除元素后："+objArray);

数组删除元素前：[第 0 个元素, 第 1 个元素, 第 2 个元素]
数组删除元素后：[第 0 个元素, 第 2 个元素]

11、数组的交、差集
**arrays1.removeAll(T[] arrays2) //arrays1删除与arrays2相同的元素

      ArrayList objArray = new ArrayList();
      ArrayList objArray2 = new ArrayList();
      objArray2.add(0,"common1");
      objArray2.add(1,"common2");
      objArray2.add(2,"notcommon");
      objArray2.add(3,"notcommon1");
      objArray.add(0,"common1");
      objArray.add(1,"common2");
      objArray.add(2,"notcommon2");
      System.out.println("array1 的元素" +objArray);
      System.out.println("array2 的元素" +objArray2);
      objArray.removeAll(objArray2);
      System.out.println("array1 与 array2 数组差集为："+objArray);

输出结果

array1 的元素[common1, common2, notcommon2]
array2 的元素[common1, common2, notcommon, notcommon1]
array1 与 array2 数组差集为：[notcommon2]

arrays1.retainAll(T[] arrays2) //arrays1获取arrays2相同的元素**

      ArrayList objArray = new ArrayList();
      ArrayList objArray2 = new ArrayList();
      objArray2.add(0,"common1");
      objArray2.add(1,"common2");
      objArray2.add(2,"notcommon");
      objArray2.add(3,"notcommon1");
      objArray.add(0,"common1");
      objArray.add(1,"common2");
      objArray.add(2,"notcommon2");
      System.out.println("array1 数组元素："+objArray);
      System.out.println("array2 数组元素："+objArray2);
      objArray.retainAll(objArray2);
      System.out.println("array2 & array1 数组交集为："+objArray);

输出结果

array1 数组元素：[common1, common2, notcommon2]
array2 数组元素：[common1, common2, notcommon, notcommon1]
array2 & array1 数组交集为：[common1, common2]

12、查找指定元素
array.contains(T obj);

      ArrayList objArray = new ArrayList();
      ArrayList objArray2 = new ArrayList();
      objArray2.add(0,"common1");
      objArray2.add(1,"common2");
      objArray2.add(2,"notcommon");
      objArray2.add(3,"notcommon1");
      objArray.add(0,"common1");
      objArray.add(1,"common2");
      System.out.println("objArray 的数组元素："+objArray);
      System.out.println("objArray2 的数组元素："+objArray2);
      System.out.println("objArray 是否包含字符串common2? ： "
      +objArray.contains("common1"));
      System.out.println("objArray2 是否包含数组 objArray? ："
      +objArray2.contains(objArray) );  //可以判断数组之间是否为子集

objArray 的数组元素：[common1, common2]
objArray2 的数组元素：[common1, common2, notcommon, notcommon1]
objArray 是否包含字符串common2? ： true
objArray2 是否包含数组 objArray? ：false

13、数组相等
equals()

      int[] ary = {1,2,3,4,5,6};
      int[] ary1 = {1,2,3,4,5,6};
      int[] ary2 = {1,2,3,4};
      System.out.println("数组 ary 是否与数组 ary1相等? ："
      +Arrays.equals(ary, ary1));
      System.out.println("数组 ary 是否与数组 ary2相等? ："
      +Arrays.equals(ary, ary2));

输出结果

数组 ary 是否与数组 ary1相等? ：true
数组 ary 是否与数组 ary2相等? ：false

14、数组的并集
根据并集的特征，唯一且全包含。
那么最符合的是set集合，所以可以直接讲n个数组添加到set集合中即可。

Zain_horse

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java实例——数组

Java实例，数组
复制链接

扫一扫

专栏目录

Java实例——数组

“相关推荐”对你有帮助么？