Java数组操作实例

雨点打透心脏的1/2处 2022-03-01 01:20 231阅读 0赞

# 数组排序及元素查找 #

使用sort()方法对Java数组进行排序，及如何使用 binarySearch() 方法来查找数组中的元素, 这边我们定义了 printArray() 方法来打印数组

执行结果：

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

--------------------

# 数组添加元素 #

使用sort()方法对Java数组进行排序，及如何使用 insertElement () 方法向数组插入元素, 这边我们定义了 printArray() 方法来打印数组：

package com.csu.test;
    
    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);
    		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();
    	}
    
    	/**
    	 * 
    	 * @param original被插入的数组
    	 * @param element被插入的元素
    	 * @param index插入的位置
    	 * @return插入了该元素的数组
    	 */
    	private static int[] insertElement(int original[], int element, int index) {
    		int length = original.length;
    		int destination[] = new int[length + 1];// 新建一个数组
    
    		// System.arraycopy() 在拷贝数组的时候，采用的使用潜复制，复制结果是一维的引用变量传递给副本的一维数组，修改副本时，会影响原来的数组。
    		// Object src : 原数组
    		// int srcPos : 从元数据的起始位置开始
    		// Object dest : 目标数组
    		// int destPos : 目标数组的开始起始位置
    		// int length : 要copy的数组的长度
    		System.arraycopy(original, 0, destination, 0, index);// 复制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

--------------------

# 获取数组长度 #

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

package com.csu.test;
    
    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

--------------------

# 数组反转 #

package com.csu.test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    
    public class Test {
    	public static void main(String[] args) {
    		ArrayList<String> arrayList = new ArrayList<String>();
    		arrayList.add("A");
    		arrayList.add("B");
    		arrayList.add("C");
    		arrayList.add("D");
    		arrayList.add("E");
    		System.out.println("反转前排序: " + arrayList);
    		Collections.reverse(arrayList);
    		System.out.println("反转后排序: " + arrayList);
    	}
    }

输出结果：

> 反转前排序: \[A, B, C, D, E\]  
> 反转后排序: \[E, D, C, B, A\]

--------------------

### 数组输出 ###

通过循环输出数组：

package com.csu.test;
    
    public class Test {
    	public static void main(String[] args) {
    		String[] runoobs = new String[3];
    		runoobs[0] = "菜鸟教程";
    		runoobs[1] = "菜鸟工具";
    		runoobs[2] = "菜鸟笔记";
    		for (int i = 0; i < runoobs.length; i++) {
    			System.out.println(runoobs[i]);
    		}
    	}
    }

以上代码运行输出结果为：

>     菜鸟教程
>     菜鸟工具
>     菜鸟笔记

--------------------

# 数组获取最大和最小值 #

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

package com.csu.test;
    
    import java.util.Arrays;
    import java.util.Collections;
    
    public class Test {
    	public static void main(String[] args) {
    		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

--------------------

### 数组合并 ###

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

package com.csu.test;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class Test {
    	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]

--------------------

# 数组填充 #

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

package com.csu.test;
    
    import java.util.Arrays;
    
    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(arrayname ,starting index ,ending index ,value) 
    		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

--------------------

# 数组扩容 #

package com.csu.test;
    
    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

--------------------

# 查找数组中的重复元素 #

package com.csu.test;
    
    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++;// 一轮只比较一个a[j]，所以count最大为1
    				}
    			}
    			if (count == 1)
    				System.out.println("重复元素 : " + a[j]);
    			count = 0;
    		}
    	}
    }

输出结果：

> 重复元素 : 5  
> 重复元素 : 6  
> 重复元素 : 2

--------------------

# 删除数组元素 #

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

package com.csu.test;
    
    import java.util.ArrayList;
    
    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);// 删掉了下标为1的元素
    		objArray.remove("第 0 个元素");
    		System.out.println("数组删除元素后：" + objArray);
    	}
    }

以上代码运行输出结果为：

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

--------------------

# 数组差集 #

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

package com.csu.test;
    
    import java.util.ArrayList;
    
    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");
    		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\]

--------------------

# 数组交集 #

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

package com.csu.test;
    
    import java.util.ArrayList;
    
    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");
            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]

--------------------

# 在数组中查找指定元素 #

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

package com.csu.test;
    
    import java.util.ArrayList;
    
    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));//比较的是对象的引用
    	}
    }

以上代码运行输出结果为：

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

--------------------

# 判断数组是否相等 #

使用 equals ()方法来判断数组是否相等：

package com.csu.test;
    
    import java.util.Arrays;
    
    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

--------------------

# 数组并集 #

使用 union ()方法来计算两个数组的并集：

package com.csu.test;
    
    import java.util.HashSet;
    import java.util.Set;
    
    public class Test {
    	public static void main(String[] args) throws Exception {
    		String[] arr1 = { "1", "2", "3" };
    		String[] arr2 = { "4", "5", "6" };
    		String[] result_union = union(arr1, arr2);
    		System.out.println("并集的结果如下：");
    
    		for (String str : result_union) {
    			System.out.println(str);
    		}
    	}
    
    	// 求两个字符串数组的并集，利用set的元素唯一性
    	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);
    	}
    }

以上代码运行输出结果为：

>     并集的结果如下：
>     3
>     2
>     1
>     6
>     5
>     4

--------------------

### 参考文献 ###

[http://www.runoob.com/java/java-examples.html][http_www.runoob.com_java_java-examples.html]

[http_www.runoob.com_java_java-examples.html]: http://www.runoob.com/java/java-examples.html