JavaSE-（一）Java语言基础-8数组
文章目录
-
- 8）数组
-
- 数组的声明与创建
- 初始化数组
- 数组的使用
- 二维数组
- Arrays类
- 数组排序
- 稀疏数组
- 练习题
-
- 1）找出数组最小值
- 2）反转数组
- 3）数组排序
- 4）找出数组最大值
- 5）合并数组
- 6）二维数组最大值
- 7）二维数组排序
8）数组
数组的声明与创建
数组是一个固定长度的，包含了相同类型数据的 容器
int[] a; 声明了一个数组变量，仅声明没创建
创建数组的时候，要指明数组的长度。new int[5];
数组下标从0开始，下标0，代表数组里的第一个数
.length属性用于访问一个数组的长度，数组访问下标范围是0到(长度-1),一旦超过这个范围,就会产生数组下标越界异常
初始化数组
//先创建，后赋值
int[] a = new int[5];
a[0] = 1;
//创建的同时赋值,两种写法
int[] a1 = new int[]{1,2,3,4};
int[] a2 = {1,2,3,4,5};
数组的使用
for each循环遍历数组
int[] a2 = {1,2,3,4,5};
for (int i:a2) {
System.out.println(i);
}
数组作为方法的参数
public static void meth(int[] i){
System.out.println(Arrays.toString(i));
}
数组做为返回值
public static int[] meth(int[] a){
int[] a1 = new int[a.length];
for (int i = 0; i < a.length ; i++) {
a1[i] = a[i]+10;
}
return a1;
}
二维数组
二维数组里面的每一个元素，都是一个一维数组,所以二维数组又叫数组的数组
int[][] a = new int[2][3];
a[1][2] = 5;
Arrays类
Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。
类里面为static的方法可以直接类名调用，
int[] a = new int[5];
Arrays.toString(a);//转换字符串
Arrays.copyOfRange(a, "0", "3")//复制数组
Arrays.toString(a)//数组排序
Arrays.binarySearch(a, 62)//搜索62在a数组中的位置，使用前必须给数组排序
Arrays.equals(a, b)//比较两个数组的内容是否一样
Arrays.fill(a, 5)//使用5填充数组
数组排序
选择排序，把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来比较完后，第一位就是最小的然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来比较完后，第二位就是第二小的，依次类推
import java.util.Arrays;
/***
* 选择排序
*/
public class Exercise {
public static void main(String[] args) {
int[] array = new int[5] ;
for (int i = 0; i < array.length-1; i++) {
int rdom = (int) (Math.random() * 100);
array[i] = rdom;
}
System.out.println("原数组"+Arrays.toString(array));
int[] array2 = sort(array);
System.out.println("排序后"+Arrays.toString(array2));
}
public static int[] sort(int[] a){
int temp;
for (int i = 0; i < a.length-1 ; i++) {
//后一次进入大循环比较的循环往后推移一个元素，所以j = i+1
for (int j = i+1; j < a.length ; j++) {
if(a[i] > a[j]){
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
return a;
}
}
冒泡排序，第一步：从第一位开始，把相邻两位进行比较如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的第二步： 再来一次，只不过不用比较最后一位
import java.util.Arrays;
/***
* 冒泡排序
*/
public class Exercise {
public static void main(String[] args) {
int[] array = new int[5] ;
for (int i = 0; i < array.length-1; i++) {
int rdom = (int) (Math.random() * 100);
array[i] = rdom;
}
System.out.println("原数组"+Arrays.toString(array));
int[] array2 = sort(array);
System.out.println("排序后"+Arrays.toString(array2));
}
public static int[] sort(int[] a){
int temp;
for (int i = 0; i < a.length-1 ; i++) {
for (int j = 0; j < a.length-1-i ; j++) {
if(a[j] > a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
System.out.println("显示每一步"+Arrays.toString(a));
}
}
}
return a;
}
}
稀疏数组
保存一个二维数组时，如果里面很多默认值为零或同一个值，因此记录了很多没有意义的数，使用稀疏数组可以解决这个问题
稀疏数组的处理方式
-
记录数组一共有几行几列，有多少个不同值
-
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
import java.util.Arrays;
/***
* 稀疏数组
*
*
* | 原数组行数 | 原数组列数 | 原数组有效数值个数
* |------------|-------------|-------------
* |有效值1所在行 | 有效值1所在列 | 有效值1的值
* |有效值2所在行 | 有效值2所在列 | 有效值2的值
* |有效值3所在行 | 有效值3所在列 | 有效值3的值
* |有效值4所在行 | 有效值4所在列 | 有效值4的值
* |有效值5所在行 | 有效值5所在列 | 有效值5的值
*
*/
public class Exercise {
public static void main(String[] args) {
int[][] array = new int[10][11];
array[8][8] = -6;
array[2][9] = 5;
array[6][2] = 18;
array[7][3] = 8;
array[9][2] = 3;
array[4][1] = 6;
System.out.println("原数组");
printArray(array);
int[][] array1 = compressArray(array);
System.out.println("压缩后的数组");
printArray(array1);
int[][] array2 = uncompressArray(array1);
System.out.println("解压后的数组");
printArray(array2);
}
public static int[][] compressArray(int[][] a) {
//获取原数组有效数值的个数
int sum = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[0].length; j++) {
if (a[i][j] != 0) {
sum++;
}
}
}
int[][] array = new int[sum + 1][3];
array[0][0] = a.length;
array[0][1] = a[0].length;
array[0][2] = sum;
int k = 1;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[0].length; j++) {
if (a[i][j] != 0) {
array[k][0] = i;
array[k][1] = j;
array[k][2] = a[i][j];
k++;
}
}
}
return array;
}
public static int[][] uncompressArray(int[][] a) {
int[][] array = new int[a[0][0]][a[0][1]];
int k = 1 ;
for (int i = 1; i <a.length ; i++) {
array[a[i][0]][a[i][1]] = a[i][2];
}
return array;
}
public static void printArray(int[][] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[0].length; j++) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
}
}
练习题
1）找出数组最小值
首先创建一个长度是5的数组，并填充随机数，通过for循环，遍历数组，找出最小的一个值出来。
import java.util.Arrays;
/***
*求最小值
*/
public class Exercise {
public static void main(String[] args) {
int[] array = new int[5];
int min = 0;
array[0] = (int) (Math.random() * 100);
array[1] = (int) (Math.random() * 100);
array[2] = (int) (Math.random() * 100);
array[3] = (int) (Math.random() * 100);
array[4] = (int) (Math.random() * 100);
min = array[0];
for (int i = 0; i < array.length; i++) {
if(min > array[i]){
min = array[i];
}
System.out.print(array[i]+"\t");
}
System.out.println();
System.out.println("最小值为:"+min);
}
}
2）反转数组
首先创建一个长度是5的数组,并填充随机数，使用for循环或者while循环，对这个数组实现反转效果
import java.util.Arrays;
/***
*反转数组
*/
public class Exercise {
public static void main(String[] args) {
int[] array = new int[5];
int temp;
array[0] = (int) (Math.random() * 100);
array[1] = (int) (Math.random() * 100);
array[2] = (int) (Math.random() * 100);
array[3] = (int) (Math.random() * 100);
array[4] = (int) (Math.random() * 100);
System.out.println("原数组："+ Arrays.toString(array));
for (int i = 0; i < array.length/2; i++) {
temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
System.out.println("反转数组："+ Arrays.toString(array));
}
}
3）数组排序
首先创建一个长度是5的数组,并填充随机数，首先用选择法正排序，然后再对其使用冒泡法倒排序
如上！
4）找出数组最大值
首先创建一个长度是5的数组,并填充随机数，用增强型for循环找出最大的那个数
和最小值的一样，大于号变小于号
5）合并数组
首先准备两个数组，他俩的长度是5-10之间的随机数，并使用随机数初始化这两个数组，然后准备第三个数组，第三个数组的长度是前两个的和，通过System.arraycopy 把前两个数组合并到第三个数组中
import java.util.Arrays;
/***
* 合并数组
*使用System.arraycopy复制两个数组到新的数组
*/
public class Exercise {
public static void main(String[] args) {
int[] array = new int[5];
int[] array1 = new int[10];
for (int i = 0; i < array.length; i++) {
array[i] = (int) (Math.random() * 100);
}
for (int i = 0; i < array1.length; i++) {
array1[i] = (int) (Math.random() * 100);
}
int[] array2 = new int[array.length+array1.length];
System.out.println("array >>>>"+Arrays.toString(array));
System.out.println("array1 >>>>"+Arrays.toString(array1));
System.arraycopy(array,0,array2,0,array.length);
System.arraycopy(array1,0,array2,array.length,array1.length);
System.out.print("array2 >>>>"+Arrays.toString(array2));
}
}
6）二维数组最大值
定义一个5X5的二维数组。 然后使用随机数填充该二维数组。找出这个二维数组里，最大的那个值，并打印出其二维坐标
import java.util.Arrays;
/***
* 二维数组最大值
*/
public class Exercise {
public static void main(String[] args) {
int[][] array = new int[5][5];
int[] max = new int[3]; //存储最大值和坐标
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
array[i][j] = (int) (Math.random() * 100);
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
max[2] = array[0][0];
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if(array[i][j] > max[2]){
max[0] = i;
max[1] = j;
max[2] = array[i][j];
}
}
}
System.out.println("最大值为:"+max[2]+"坐标为："+max[0]+","+max[1]);
}
}
7）二维数组排序
首先定义一个5X8的二维数组，然后使用随机数填充满。借助Arrays的方法对二维数组进行排序。
import java.util.Arrays;
/***
* 二维数组排序
*/
public class Exercise {
public static void main(String[] args) {
int[][] array = new int[10][5];
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
array[i][j] = (int) (Math.random() * 100);
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
//将生成的二维数组变成一维数组
int[] a = new int[array.length*array[0].length];
for (int i = 0; i < array.length; i++) {
System.arraycopy(array[i],0,a,array[i].length*i,array[i].length);
}
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//将排好序的一维数组写入二维数组中
int k = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
array[i][j] = a[k];
k++;
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
}