0
点赞
收藏
分享

微信扫一扫

Java基础(数组)

  • 学习自B站:【狂神说Java】Java零基础学习视频通俗易懂

  • Java基础(数组)

数组声明创建

package com.HJX.array;
 ​
 public class ArrayDemo01 {
 ​
     public static void main(String[] args) {
 ​
         int[] nums1; // 1.声明一个数组
         nums1 = new int[10]; //2.创建一个数组:可以存放10个int类型的数字
         //3.给数组元素中赋值
         nums1[0] = 1;
         nums1[1] = 2;
         nums1[2] = 3;
         nums1[3] = 4;
         nums1[4] = 5;
         nums1[5] = 6;
         nums1[6] = 7;
         nums1[7] = 8;
         nums1[8] = 9;
         nums1[9] = 10;
 ​
         //计算所有元素的和
         int sum = 0;
         //获取数组的长度:nums1.length
         for (int i = 0; i < nums1.length; i++) {
             sum = sum +nums1[i];
         }
 ​
         System.out.println(sum);
 ​
     }
 }

package com.HJX.array;
 ​
 public class ArrayDemo02 {
 ​
     public static void main(String[] args) {
 ​
         //静态初始化:  创建 + 赋值
         int[] a = {1,2,3,4,5,6,7,8};
         System.out.println(a[0]);
 ​
         //动态初始化: 包含默认初始化
         int[] b = new int[10];
         b[0] = 10;
         System.out.println(b[0]); // 10
         System.out.println(b[1]); // 0
         
     }
 }

  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合

  • 数组也是对象。数组元素相当于对象的成员变量

  • 数组的长度是确实的,不可变的。如果越界,则报:ArrayIndexOutofBounds

package com.HJX.array;
 ​
 public class ArrayDemo03 {
 ​
     public static void main(String[] args) {
 ​
         int[] arrays = {1,2,3,4,5};
 ​
         //打印全部的数组元素
         for (int i = 0; i < arrays.length; i++) {
             System.out.println(arrays[i]);
         }
         System.out.println("------------------");
 ​
         //计算所有元素的和
         int sum = 0;
         for (int i = 0; i < arrays.length; i++) {
             sum = sum + arrays[i];
         }
         System.out.println(sum); //15
         System.out.println("------------------");
 ​
         //查找最大元素
         int max = arrays[0];
         for (int i = 0; i < arrays.length; i++) {
             if (arrays[i] > max){
                 max = arrays[i];
             }
         }
         System.out.println(max); //5
 ​
     }
 }

 package com.HJX.array;
 ​
 public class ArrayDemo04 {
 ​
     public static void main(String[] args) {
 ​
         int[] arrays = {1,2,3,4,5};
 ​
 //        //遍历元素,没有下标(for-each循环)
 //        for (int array : arrays) {
 //            System.out.println(array);
 //        }
 ​
         printArray(arrays); //1 2 3 4 5
         System.out.println();
 ​
         int[] reverse = reverse(arrays);
         printArray(reverse); //5 4 3 2 1
 ​
     }
 ​
     //打印数组元素
     public static void printArray(int[] arrays){
         for (int i = 0; i < arrays.length; i++) {
             System.out.print(arrays[i]+" ");
         }
     }
 ​
     //反转数组
     public static int[] reverse(int[] arrays){
         int[] result = new int[arrays.length];
 ​
         //反转的操作
         for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
             result[j] = arrays[i];
         }
         return result;
     }    
 }

二维数组

 package com.HJX.array;
 ​
 public class ArrayDemo05 {
 ​
     public static void main(String[] args) {
         //二维数组[4][2]
         /*
            1,2  array[0]
            2,3  array[1]
            3,4  array[2]
            4,5  array[3]
         */
         int[][] array = {{1,2},{2,3},{3,4},{4,5}};
 ​
         //打印二维数组
         for (int i = 0; i < array.length; i++) {
             for (int j = 0; j < array[i].length; j++) {
                 System.out.println(array[i][j]);
             }
         }
         System.out.println("-------------------");
 ​
         printArray(array[0]);// 输出: 1
                              //      2
         System.out.println("-------------------");
         System.out.println(array[0][0]); // 1
 ​
     }
 ​
     //打印数组元素
     public static void printArray(int[] arrays){
         for (int i = 0; i < arrays.length; i++) {
             System.out.println(arrays[i]);
         }
     }
     
 }

package com.HJX.array;
 ​
 import java.util.Arrays;
 ​
 public class ArrayDemo06 {
 ​
     public static void main(String[] args) {
 ​
         int[] a = {1,2,3,456,789,111000,9};
 ​
         System.out.println(a); // [I@1b6d3586
         //打印数组元素
         System.out.println(Arrays.toString(a)); // [1, 2, 3, 456, 789, 111000,9]
 ​
         Arrays.sort(a);//对数组进行排序(升序)
         System.out.println(Arrays.toString(a)); // [1, 2, 3, 9, 456, 789, 111000]
 ​
         Arrays.fill(a,2,4,0);//数组填充(第3个元素与第4个元素被0填充)
         System.out.println(Arrays.toString(a)); // [1, 2, 0, 0, 456, 789, 111000]
 ​
     }
 }

冒泡排序

package com.HJX.array;
 ​
 import java.util.Arrays;
 ​
 public class ArrayDemo07 {
 ​
     //冒泡排序
     //1.比较数组中两个相邻的元素,若第一个数比第二个数大,就交换位置
     //2.每一次比较,都会产生出一个最大或最小的数字
     //3.下一轮则可以少一次排序,依次循环直至结束
 ​
     public static void main(String[] args) {
 ​
         int[] a = {1,6,8,3,5,9};
 ​
         int[] sort = sort(a);//调用完自己写的排序方法后,返回一个排序后的数组
 ​
         System.out.println(Arrays.toString(sort));// [1, 3, 5, 6, 8, 9]
 ​
     }
 ​
     public static  int[] sort(int[] array){
         //定义临时变量
         int temp = 0;
 ​
         //外层循环,判断要走多少次
         for (int i = 0; i < array.length-1; i++) {
             //内层循环,比较两个数,如果第一个数比第二个数大,就交换位置
             for (int j = 0; j < array.length-1-i; j++) {
                 if (array[j+1] < array[j]){
                     temp = array[j];
                     array[j] = array[j+1];
                     array[j+1] = temp;
                 }
             }
         }
         return array;
     }
 }

稀疏数组

package com.HJX.array;
 ​
 public class ArrayDemo08 {
 ​
     public static void main(String[] args) {
 ​
         //1.创建一个二维数组 11*11   0:没有棋子  1:黑棋  2:白棋
         int[][] array1 = new int[11][11];
         array1[1][2] = 1;
         array1[2][3] = 2;
         //输出原始的数组
         System.out.println("输出原始的数组");
 ​
         for (int[] ints : array1) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
             }
             System.out.println();
         }
 ​
         System.out.println("-------------------------");
 ​
         //转换为稀疏数组来保存
         //获取有效值的个数
         int sum = 0;
         for (int i = 0; i < 11; i++) {
             for (int j = 0; j < 11; j++) {
                 if (array1[i][j] != 0){
                     sum++;
                 }
             }
         }
         System.out.println("有效值的个数:"+sum);
 ​
         //2.创建一个稀疏数组
         int[][] array2 = new int[sum+1][3];
 ​
         array2[0][0] = 11;
         array2[0][1] = 11;
         array2[0][2] = sum;
 ​
         //遍历二维数组,将非零的值存放进稀疏数组中
         int count = 0;
         for (int i = 0; i < array1.length; i++) {
             for (int j = 0; j < array1[i].length; j++) {
                 if (array1[i][j] != 0){
                     count++;
                     array2[count][0] = i;
                     array2[count][1] = j;
                     array2[count][2] = array1[i][j];
                 }
             }
         }
 ​
         //输出稀疏数组
         System.out.println("稀疏数组");
 ​
         for (int i = 0; i < array2.length; i++) {
             System.out.println(array2[i][0]+"\t"
                     +array2[i][1]+"\t"
                     +array2[i][2]+"\t");
         }
         System.out.println("-------------------");
 ​
         System.out.println("还原");
         //1.读取稀疏数组
         int[][] array3 = new int[array2[0][0]][array2[0][1]];
 ​
         //2.给其中的元素还原它的值
         for (int i = 1; i < array2.length; i++) {
             array3[array2[i][0]][array2[i][1]] = array2[i][2];
         }
 ​
         //3.打印
         //输出原始的数组
         System.out.println("输出还原的数组");
 ​
         for (int[] ints : array3) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
             }
             System.out.println();
         }
         
     }
 }
举报

相关推荐

0 条评论