4.3. 数组的基本操作¶
4.3.1. 遍历数组¶
遍历一维数组¶
import java.util.*;
public class Rakel { // 创建类
public static void main(String[] args) { // 主方法
// 定义String型数组str
String str[] = new String[]{"ab", "cd", "ef", "yz"};
Arrays.sort(str); // 将数组进行排序
for (int i = 0; i <str.length ; i++) {
System.out.println(str[i]);
}
for (String i : str) {
System.out.printf("%s \n", i);
}
// 在指定的范围内搜索元素"cd"的索引位置
int index = Arrays.binarySearch(str, 0, 2, "cd");
System.out.println("cd的索引位置是：" + index); // 将索引输出
}
}
遍历二维数¶
遍历数组就是获取数组中的每个元素，通常使用for循环来实现，遍历二维数组需要使用双层for循环，通过length属性可获得数组的长度。
for循环
eg
public class array5 {
// 主方法
public static void main(String[] args) {
// 定义二维数组
int b[][] = new int[][] {{1},{2,3},{4,5,6}};
for (int i = 0; i < b.length; i++) {
// 遍历二维数组中的每个元素
for (int j = 0; j < b[i].length; j++) {
System.out.println(b[i][j]); //将数组中的元素输出
}
System.out.println(); //输出空格
}
}
}
使用foreach语句来遍历二维数组
eg
public class foreach_array1 {
public static void main(String[] args) {
// 主方法
// 定义二维数组
int arr2[][] = {{4,3},{1,2}};
// 打印提示信息
System.out.println("数组中的元素是：");
// 定义外层循环计数器
int i=0;
// 外层循环变量为以为数组
for (int x[] : arr2) {
// 外层计数器递增
i++;
int j=0; //定义内层循环计数器
for (int e : x) { //循环遍历每一个数组元素
j++; //内层计数器递增
if (i==arr2.length && j==x.length) { //判断二维数组中的最后一个元素
System.out.print(e); //输出二维数组的最后一个元素
} else {
//如果不是二维数组中的最后一个元素
System.out.print(e+"、"); //输出信息
}
}
}
}
}
4.3.2. 填充替换数组元素¶
数组中的元素定义完成后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换。 方法为：
fill(int[] a,int value)
a:要进行替换的数组
value：要存储数组中所有元素的值
eg
import java.util.Arrays; //导入java.util.Arrays类
public class array6 {
//主方法
public static void main(String[] args) {
// 创建int型数组
int arr[] = new int[5];
Arrays.fill(arr, 8); //使用同一个值对数组进行填充
for (int i = 0; i < arr.length; i++) { //循环遍历数组中的元素
// 将数组中的元素依次输出
System.out.println("第"+i+"个元素是："+arr[i]);
}
}
}
//输出结果
第0个元素是：8
第1个元素是：8
第2个元素是：8
第3个元素是：8
第4个元素是：8
注意：数组若原有值将会被覆盖。
eg 覆盖数组下标索引的范围
import java.util.Arrays;
public class test7 {
// 主方法
public static void main(String[] args) {
// 定义数组
int arr[]= {1,2,3,4,5,6,7,8};
// 填充替换数组索引范围2~4下标
Arrays.fill(arr, 2, 4, 88);
// 遍历打印出数组的值
for (int i = 0; i < arr.length; i++) {
System.out.println("第"+i+"个元素的值是："+arr[i]);
}
}
}
// 输出信息
第0个元素的值是：1
第1个元素的值是：2
第2个元素的值是：88
第3个元素的值是：88
第4个元素的值是：5
第5个元素的值是：6
第6个元素的值是：7
第7个元素的值是：8
注意：指定的索引位置大于或等于要进行填充的数组的长度。就会报出ArrayIndexOutif-BoundsException异常
eg: 隐藏电话号码的例子
import java.util.Arrays;
public class test8 {
public static void main(String[] args) {
// 定义电话号码的数组
int arr[]= {1,3,2,6,2,6,6,2,2,1,6};
// 进行数组替换,repleace 2~6 index
Arrays.fill(arr, 3, 7, 0);
for (int i = 0; i < arr.length; i++) {
// 判断替换后为0的打印输出为*
if (arr[i]==0) {
System.out.print("*");
}
else {
// 原样输出数组
System.out.print(arr[i]);
}
}
}
}
//输出结果
132****2216
4.3.3. 对数组进行排序¶
Arrays Sort()方法 Arrays.sort(arr)；
int arr[] = new int[] {23,42,12,84} ；
Arrays.sort(arr);
eg:
import java.util.Arrays;
public class Array_sort {
// 主方法
public static void main(String[] args) {
// 创建一个数组，无序的
int arr1[]= new int[]{11,22,33,88,31,21,55};
// 对数组进行排序
Arrays.sort(arr1);
// 打印排序后数组的值
for(int tmp:arr1) {
System.out.print(tmp + " ");
}
}
}
//输出结果
11 21 22 31 33 55 88
eg
import java.util.Arrays;
public class Array_sort {
// 主方法
public static void main(String[] args) {
// 创建一个数组，无序的
// int arr1[]= new int[]{11,22,33,88,31,21,55};
double b[] = new double[] {12.0,1.1,22.2,44.6};
// 对数组进行排序
Arrays.sort(b);
// 打印排序后数组的值
for(double tmp:b) {
System.out.print(tmp + " ");
}
}
}
//输出结果
1.1 12.0 22.2 44.6
sort()方法只有升序的一种结果。局限性很大
4.3.4. 复制数组¶
eg
public class array_copy {
public static void main(String[] args) {
// 定义arr1数组
int arr1[]= {1,2,3};
// 定义arr2数组
int arr2[]=arr1;
arr2[0]=88;
System.out.println("arr1数组：");
// 打印arr1数组内容，遍历arr1
for (int tmp:arr1) {
System.out.print(tmp+" ");
}
// 打印arr2数组内容，遍历arr2
System.out.println("\narr2数组：");
for (int tmp:arr2) {
System.out.print(tmp+" ");
}
}
}
//输出内容
arr1数组：
88 2 3
arr2数组：
88 2 3
eg
import java.util.Arrays;
public class array_copy {
public static void main(String[] args) {
// 定义arr1数组
int arr1[]= {1,2,3};
// 定义arr2数组,内存中开辟了一个新的区域，2代表数组的长度，大于长度补充0，
int arr2[]=Arrays.copyOf(arr1, 2);
arr2[0]=88;
System.out.println("arr1数组：");
// 打印arr1数组内容，遍历arr1
for (int tmp:arr1) {
System.out.print(tmp+" ");
}
// 打印arr2数组内容，遍历arr2
System.out.println("\narr2数组：");
for (int tmp:arr2) {
System.out.print(tmp+" ");
}
}
}
//输出结果
arr1数组：
1 2 3
arr2数组：
88 2
eg
import java.util.Arrays;
public class array_copy2 {
public static void main(String[] args) {
// 定义arr1数组
int arr1[]= {1,2,3,4,5,6,7,8};
// 定义arr2数组,内存中开辟了一个新的区域，copy 2~5索引的值
int arr2[]=Arrays.copyOfRange(arr1, 2, 4+1);
System.out.println("arr1数组：");
// 打印arr1数组内容，遍历arr1
for (int tmp:arr1) {
System.out.print(tmp+" ");
}
// 打印arr2数组内容，遍历arr2
System.out.println("\narr2数组：");
for (int tmp:arr2) {
System.out.print(tmp+" ");
}
}
}
// 输出结果
arr1数组：
1 2 3 4 5 6 7 8
arr2数组：
3 4 5
4.3.5. 数组的查询¶
import java.util.Arrays;
public class array_search1 {
// 主方法
public static void main(String[] args) {
// create array
int arr1[]= {7,5,8,2,3,1,9};
//将数组进行排序
Arrays.sort(arr1);
// 查找数组中元素8的索引位置
int index=Arrays.binarySearch(arr1, 8);
System.out.println("8的索引位置是："+ index);
}
}
//输出结果
8的索引位置是：5
eg
import java.util.Arrays;
public class array_search2 {
// 主方法
public static void main(String[] args) {
//定义String型数组str
String str[]= new String[] {"ab","cd","ef","yz"};
// 对数组进行排序
Arrays.sort(str);
// 在指定范围内搜索元素"cd"的索引位置
int index= Arrays.binarySearch(str, 0, 2, "cd");
// 输出索引位置
System.out.println("cd 的索引位置是："+ index);
}
}
//输出信息
cd 的索引位置是：1
4.3.6. 数组排序¶
冒泡排序¶
eg
public class maopao_paixu {
// 主方法
public static void main(String[] args) {
// 定义一个int型数组
int a[]= {11,33,6,88,32,79,232};
// 遍历数组元素，遍历2次
for (int i = 1; i < a.length; i++) {
for (int j = 0; j < a.length-1; j++) {
if(a[j]>a[j+1]) {
// 将第1个位置的数和第2位置的数，互换位置
int tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
System.out.println("冒泡排序的结果：");
for(int tmp:a) {
System.out.print(tmp+ "->");
}
}
}
//输出信息
冒泡排序的结果：
6->11->32->33->79->88->232->
if(a[j]<a[j+1]) {
// 将第1个位置的数和第2位置的数，互换位置
int tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
#可以实现降序，输出结果：
冒泡排序的结果：
232->88->79->33->32->11->6->
选择排序¶
选择排序的过程
eg
/**
* 直接选择排序算法实例
*
* @author Li Zhong Wei
*/
public class SelectSort {
public static void main(String[] args) {
// 创建一个数组，这个数组元素是乱序的
int[] array = { 63, 4, 24, 1, 3, 15 };
// 创建直接排序类的对象
SelectSort sorter = new SelectSort();
// 调用排序对象的方法将数组排序
sorter.sort(array);
}
/**
*直接选择排序法
*
* @param array
* 要排序的数组
*/
public void sort(int[] array) {
int index;
for (int i = 1; i < array.length; i++) {
index = 0;
for (int j = 1; j <= array.length - i; j++) {
if (array[j] > array[index]) {
index = j;
}
}
// 交换在位置array.length-i和index(最大值)两个数
int temp = array[array.length - i];// 把第一个元素值保持到临时变量中
array[array.length - i] = array[index];// 把第二个元素值保存到第一个元素单元中
array[index] = temp;// 把临时变量也就是第一个元素原值保持到第二个元素中
}
showArray(array);// 输出直接选择排序后的数组值
}
/**
* 显示数组所有元素
*
* @param array
* 要显示的数组
*/
public void showArray(int[] array) {
for (int i : array) {// foreach格式遍历数组
System.out.print(" >" + i);// 输出每个数组元素值
}
System.out.println();
}
}
//输出结果为
选择排序的结果为：
>1 >3 >4 >15 >24 >63
修改如下，即可实现降序
if (array[j] < array[index]) {
index = j;
}
}
//输出结果
>63 >24 >15 >4 >3 >1
反转排序¶
实现思路：把数组的最后一个元素和第一个元素替换，倒数第二个元素和第二个元素替换， 依次类推，直到把所有数组元素反转替换。
算法示例：反转排序是对数组两边的元素进行替换，只需要循环数组长度的半数次。如果数组长度为7，
那么for循环只需要循环3次。
eg
import java.util.Arrays;
public class ReverseSort {
// 主方法
public static void main(String[] args) {
// 创建一个数组
int[] array = { 10, 20, 30, 40, 50, 60 };
// 创建反转排序类的对象
ReverseSort sorter = new ReverseSort();
// 调用排序对象的方法将数组反转
sorter.sort(array);
}
/*
* 反转排序
*
* @param array 要排序的数组
*/
private void sort(int[] array) {
System.out.println("数组原有内容 ：");
showArray(array); // 输出排序前数组值
int temp;
int len = array.length; // 获取数组的长度
for (int i = 0; i < len / 2; i++) {
// 只循环数组长度的半数次
temp = array[i]; // 数组的值
// 进行数值对调
array[i] = array[len - 1 - i];
array[len - 1 - i] = temp;
}
System.out.println("\n数组反转后内容： ");
showArray(array); // 输出排序后的数组值
}
/*
* 显示数组中的索引元素
*
* @param array 要显示的数组
*/
public void showArray(int[] array) {
for (int temp : array) {
// 遍历数组
System.out.print("\t" + temp); // 输出每个元素的值
}
}
}
//输出内容
数组原有内容 ：
10 20 30 40 50 60
数组反转后内容：
60 50 40 30 20 10
4.3.7. 课后练习¶
1.编写Java程序，创建数组arr1和arr2，将数组arr1中索引位置是0~3的元素赋值到数组arr2中，最后将 数组str1和str2的元素输出。
import java.util.Arrays;
public class array_test1 {
public static void main(String[] args) {
// 定义数组arr1
int[] arr1= {1,2,3,4,5,6};
// 定义数组arr2
int [] arr2=Arrays.copyOfRange(arr1, 0, 3);
System.out.println("arr1数组的值为： ");
for (int i = 0; i < arr1.length; i++) {
System.out.print( arr1[i]);
}
System.out.println();
System.out.println("arr2数组的值为： ");
for (int i = 0; i < arr2.length; i++) {
System.out.print( arr2[i]);
}
}
}
//输出结果
/*
arr1数组的值为：
123456
arr2数组的值为：
123
*/
2.编写Java程序，将数组中最小的数输出
import java.util.Arrays;
public class array_test2 {
public static void main(String[] args) {
int[] array= {6,5,4,3,7,8,1};
System.out.println("数组的内容是：");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
}
System.out.println();
Arrays.sort(array);
System.out.println("数组中的最小值为："+array[0]);
}
}
/*
数组的内容是：
6543781
数组中的最小值为：1
*/
3.编写Java程序，实现将数组arr中索引位置是2的元素替换为“bb”,并将替换前数组中的元素和替换后的 数组中的元素全部输出。
import java.util.Arrays;
public class array_test3 {
public static void main(String[] args) {
// 定义数组arr
int arr[] = { 1, 4, 5, 6, 7, 8, 9, 10 };
System.out.println("arr 数组的值为： ");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
Arrays.fill(arr, 2, 3, 0);
System.out.println();
System.out.println("将索引位置是2的数替换为‘bb’后的输出： ");
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 0) {
System.out.print("bb" + " ");
} else {
System.out.print(arr[i] + " ");
}
}
}
}
/*
arr 数组的值为：
1 4 5 6 7 8 9 10
将索引位置是2的数替换为‘bb’后的输出：
1 4 bb 6 7 8 9 10
*/
import java.util.*;
public class Text { // 创建类
public static void main(String[] args) {
String arr[] = new String[] { "ac", "bc", "dc", "yc" };
System.out.println("替换前：");
for (String str : arr) {
System.out.print(str+"\t");
}
Arrays.fill(arr, 2, 3, "bb");
System.out.println("\n替换后：");
for (String str2 : arr) {
System.out.print(str2+"\t");
}
}
}
4.创建一个二维数组，进行转换展示的数组信息
public class array2_show { // 创建类
public static void main(String[] args) {
int arr[][]=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
System.out.println("数组原有内容：");
for(int i = 0;i<arr.length;i++){
for(int j=0;j<arr.length;j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println("行列互换后数组内容：");
for(int i = 0;i<arr.length;i++){
for(int j=0;j<arr.length;j++){
System.out.print(arr[j][i] + " ");
}
System.out.println();
}
}
}
/*
数组原有内容：
1 2 3
4 5 6
7 8 9
行列互换后数组内容：
1 4 7
2 5 8
3 6 9
*/