Java数组

Java数组

      • 数组排序及元素位置查找
      • 数组添加元素
      • 获取多维数组长度
      • 数组反转
      • 数组获取最大值和最小值
      • 数组合并
      • 数组填充
      • 数组扩容
      • 查找数组中的重复元素
      • 删除数组元素
      • 判断数组是否相等
      • 数组查找指定元素
      • 数组的差集
      • 数组的交集
      • 数组的并集


数组排序及元素位置查找

使用sort()方法对Java数组进行排序
使用 binarySearch() 方法来查找数组中的元素的位置。
(Arrays.binarySearch方法使用前,需要对数组排序,才能定位值插入位置,因为binarySearch采用二分搜索法)

import java.util.*;
public class Test{
    public static void main(String args[]) {
        int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
        Arrays.sort(array);
        for (int x:array) {
            System.out.println(x);
        }
        int index = Arrays.binarySearch(array, 2);
        System.out.println("元素 2 在第 " + index + " 个位置");
    }
}
/* 输出结果: 
-9 -7 -3 -2 0 2 4 5 6 8  
元素 2 在第 5 个位置
 */

数组添加元素

一般数组是不能添加元素的,因为他们在初始化时就已定好长度了,不能改变长度。
但ArrayList数组可以改变大小,用add(element)方法往里添加元素,还可add(index,element)往指定下标处添加元素

  • 方法一:使用 insertElement () 方法向数组插入元素

    import java.util.Arrays;
    public class Test{
        public static void main(String args[]) throws Exception {
            int array[] = { 2, 5, -2, 6, -3, 8, 0, -7, -9, 4 };
            Arrays.sort(array);
            int index = Arrays.binarySearch(array, 1);
            System.out.println("元素 1 所在位置(负数为不存在):"
                    + index);
            int newIndex = -index - 1;
            array = insertElement(array, 1, newIndex);
            System.out.println("添加元素1后:"+Arrays.toString(array));
        }
    
        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;
        }
    }
    /* 输出结果: 
    	元素 1 所在位置(负数为不存在):-6
    	添加元素1:[-9, -7, -3, -2, 0, 1, 2, 4, 5, 6, 8]
     */
    
  • 方法二:把数组转化为集合,向集合中添加元素,再将集合转化为数组

    import java.util.*;
    public class Test{
        public static void main(String[] args) {
            String[] arr = {"ID", "姓名"};
            // 将数组转化为集合 1
            List<String> list1 = Arrays.asList(arr);
            List<String> list2 = new ArrayList<>();
            // 定义集合 2 、并向其中添加元素: 性别
            list2.add("性别");
            List<String> List = new ArrayList<String>();
            // 定义新集合、将集合1、2中的元素添加到新集合
            List.addAll(list1);
            List.addAll(list2);
            // 将新集合转化回新数组
            String[] newArr = List.toArray(new String[List.size()]);
            System.out.println(Arrays.toString(newArr));
        }
    }
    /* 输出结果: [ID, 姓名, 性别]  */
    

获取多维数组长度

使用数组的属性 length 获取数组的长度。

public class Test{
    public static void main(String args[]) {
        String[][] data = new String[2][5];
        System.out.println("第一维数组长度: " + data.length);
        System.out.println("第二维数组长度: " + data[0].length);
    }
}
	/* 输出结果: 第一维数组长度: 2 ,第二维数组长度: 5   */

数组反转

使用 Collections.reverse(ArrayList) 将数组进行反转

public class Test{
    public static void main(String args[]) {
        ArrayList List = new ArrayList();
        List.add(2);
        List.add(3);
        List.add(4);
        System.out.println(List.toString());
        Collections.reverse(List);
        System.out.println(List.toString());
    }
}
/* 输出结果: 
反转前:[2, 3, 4]
反转后:[4, 3, 2]
*/

数组获取最大值和最小值

通过 Collections 类的 Collections.max()Collections.min() 方法来查找数组中的最大和最小值


import java.util.Collections;
import java.util.Arrays;
public class Test{
    public static void main(String[] args) {
        Integer[] List = { 8, 2, 7, 1, 4, 9, 5};
        int min = (int) Collections.min(Arrays.asList(List));
        int max = (int) Collections.max(Arrays.asList(List));
        System.out.println("最小值: " + min);
        System.out.println("最大值: " + max);
    }
}
/* 输出结果: 
最小值: 1
最大值: 9
*/

数组合并

通过 List 类的 list.Addall(array1.asList(array2) 方法将两个数组合并为一个数组

import java.util.*;
public class Test{
    public static void main(String args[]) {
        String a[] = { "l", "x", "a" };
        String b[] = { "c", "y" };
        List list = new ArrayList(Arrays.asList(a));
        list.addAll(Arrays.asList(b));
        Object[] c = list.toArray();
        System.out.println(Arrays.toString(c));
    }
}
/* 输出结果: 
[l, x, a, c, y]
*/

数组填充

通过 Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname ,starting index ,ending index ,value) 方法向数组中填充元素

import java.util.*;
public class Test{
    public static void main(String args[]) {
        int array[] = new int[6];
        Arrays.fill(array, 100);
        for (int i=0, n=array.length; i< n; i++) {
            System.out.println(array[i]);
        }
        System.out.println();
        Arrays.fill(array, 3, 6, 50);
        for (int i=0, n=array.length; i< n; i++) {
            System.out.println(array[i]);
        }
    }
}
/* 输出结果: 
100 100 100 100 100 100 

100 100 100 50 50 50
*/

数组扩容

在数组初始化后对数组进行扩容

public class Test{
    public static void main(String[] args) {
        String[] names = new String[] { "A", "B", "C" };
        String[] extended = new String[5];
        extended[3] = "D";
        extended[4] = "E";
        System.arraycopy(names, 0, extended, 0, names.length);
        for (String str : extended){
            System.out.println(str);
        }
    }
}
/* 输出结果: 
A B C D E
*/

查找数组中的重复元素

public class Test{
    public static void main(String[] args)
    {
        int[] my_array = {1, 2, 5, 5, 6, 6, 7, 2, 9, 2};
        findDupicateInArray(my_array);
    }
    public static void findDupicateInArray(int[] a) {
        int count=0;
        for(int j=0;j<a.length;j++) {
            for(int k =j+1;k<a.length;k++) {
                if(a[j]==a[k]) {
                    count++;
                }
            }
            if(count==1)
                System.out.println( "重复元素 : " +  a[j] );
            count = 0;
        }
    }
}
/* 输出结果: 
重复元素 : 5
重复元素 : 6
重复元素 : 2
*/

删除数组元素

使用 remove () 方法来删除数组元素

public class Test{
    public static void main(String[] args)  {
        ArrayList<String> objArray = new ArrayList<String>();
        objArray.clear();
        objArray.add(0,"第 0 个元素");
        objArray.add(1,"第 1 个元素");
        objArray.add(2,"第 2 个元素");
        System.out.println("数组删除元素前:"+objArray);
        objArray.remove(1);
        objArray.remove("第 0 个元素");
        System.out.println("数组删除元素后:"+objArray);
    }
}
/* 输出结果: 
数组删除元素前:[第 0 个元素, 第 1 个元素, 第 2 个元素]
数组删除元素后:[第 2 个元素]
*/

判断数组是否相等

import java.util.*;
public class Test{
    public static void main(String[] args) throws Exception {
        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
*/

数组查找指定元素

使用 contains () 方法来查找数组中的指定元素

import java.util.*;
public class Test{
    public static void main(String[] args)  {
        ArrayList<String> objArray = new ArrayList<String>();
        ArrayList<String> objArray2 = new ArrayList<String>();
        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("common2"));
        System.out.println("objArray2 是否包含数组 objArray? :"
                +objArray2.contains(objArray) );
    }
}
/* 输出结果: 
objArray 的数组元素:[common1, common2]
objArray2 的数组元素:[common1, common2, notcommon, notcommon1]
objArray 是否包含字符串common2? : true
objArray2 是否包含数组 objArray? :false
*/

数组的差集

使用 removeAll () 方法来计算两个数组的差集

import java.util.*;
public class Test{
    public static void main(String[] args)  {
        ArrayList objArray1 = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray1.add(0,"common1");
        objArray1.add(1,"common2");
        objArray1.add(2,"notcommon2");
        System.out.println("array1 的元素" +objArray1);
        System.out.println("array2 的元素" +objArray2);
        objArray1.removeAll(objArray2);
        System.out.println("array1 与 array2 数组差集为:"+objArray1);
    }
}
/* 输出结果: 
array1 的元素[common1, common2, notcommon2]
array2 的元素[common1, common2, notcommon]
array1 与 array2 数组差集为:[notcommon2]
*/

数组的交集

使用 retainAll () 方法来计算两个数组的交集

import java.util.*;
public class Test{
    public static void main(String[] args)  {
        ArrayList objArray1 = new ArrayList();
        ArrayList objArray2 = new ArrayList();
        objArray2.add(0,"common1");
        objArray2.add(1,"common2");
        objArray2.add(2,"notcommon");
        objArray1.add(0,"common1");
        objArray1.add(1,"common2");
        objArray1.add(2,"notcommon2");
        objArray1.retainAll(objArray2);
        System.out.println("array1 与 array2 数组交集为:"+objArray1);
    }
}
/* 输出结果: 
array1 与 array2 数组交集为:[common1, common2]
*/

数组的并集

利用set,自定义 union ()方法来计算两个数组的并集

import java.util.*;
public class Test{
    public static void main(String[] args) throws Exception {
        String[] arr1 = { "1", "2", "3","4","5" };
        String[] arr2 = { "4", "5", "6" };
        String[] result_union = union(arr1, arr2);
        System.out.println("并集的结果如下:");

        for (String str : result_union) {
            System.out.println(str);
        }
    }
    public static String[] union(String[] arr1, String[] arr2) {
        Set<String> set = new HashSet<String>();
        for (String str : arr1) {
            set.add(str);
        }
        for (String str : arr2) {
            set.add(str);
        }
        String[] result = {  };
        return set.toArray(result);
    }
}
/* 输出结果: 
1 2 3 4 5 6
*/

你可能感兴趣的:(Java)