首页 > 其他分享 >数组部分基础&冒泡排序

数组部分基础&冒泡排序

时间:2022-11-22 04:11:07浏览次数:74  
标签:arr nums int 基础 System 冒泡排序 length 数组

数组基础知识

 

1.数组的创建

格式:变量(数组)类型 变量(数组)名 = 变量(数组)值

  1. int[] nums ; // 声明一个数组

    nums = new int[10]; // 创建一个数组

  2. int[] nums = new int[10]; // 创建并声明一个数组

  3. nums[0] = 1;

    nums[1] = 2;

    nums[2] = 3;

    nums[3] = 4;

    nums[4] = 5;

    nums[5] = 6;

    nums[6] = 7;

    nums[7] = 8;

    nums[8] = 9;

    nums[9] = 10; // 给数组元素赋值

     

     // 计算所有元素的和
           int sum = 0;

           // 获取数组长度:arrays.length
           for (int i = 0; i < nums.length; i++) {
               sum += nums[i];
          }
           System.out.println(sum);

     

2.数组的初始化

  1. 静态初始化

    // 静态初始化:创建 + 赋值
           int[]   a = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8};
  2. 动态初始化

    // 动态初始化
           int [] b = new int[10];
           b[0] = 10;

           System.out.println(b[0]); // 动态
  3. 默认初始化

    int [] b = new int[10];
           b[0] = 10;

           System.out.println(b[0]); // 动态
    System.out.println(b[1]); // 默认
    System.out.println(b[2]); // 默认
    System.out.println(b[3]); // 默认

     

小结

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

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

  • 数组长度是确定的,不可变的。如果越界,则报:ArrayIndexOutofBounds(下标越界异常)

数组的使用

  • 普通的for循环

  • for-each循环

            // JDK1.5,没有下标
    //       for (int array : arrays) {
    //           System.out.println(array);
    //       }
    //       reverse(arrays);
  • 数组作为方法入参

        // 打印数组元素
       public static void printArray(int[] arrays){
           for (int i = 0; i < arrays.length; i++) {
               System.out.print(arrays[i] + " ");
          }
           System.out.println();
      }
  • 数组作返回值

    // 反转数组
    public static int[] reverse(int[] arrays){
       int[] reverse = new int[arrays.length];
       for(int i = 0,j = reverse.length - 1;i < arrays.length;i++, j--){
           reverse[j] = arrays[i];
      }
       return reverse;
    }

     

二维数组

遍历二维数组

 

    // 创建一个二维数组
       int[][] array = {{1 , 2 , 3} , {2 , 3} , {3 , 4} , {4 , 5}};

       for (int i = 0; i < array.length; i++) { // array.length为外层数组个数
           for (int j = 0; j < array[i].length; j++) { // array[i].length为内层每个数组的长度
               System.out.println(array[i][j]);
          }
      }
  }

 

冒泡排序

 

package com.kuang.array;

public class ArrayDemo07 {
   public static void main(String[] args) {
       int[] arr = {9 , 6 , 7 , 4 , 3 , 5 , 8 , 2};

       search(arr);
       sort(arr);
       System.out.println();
       search(arr);
  }

   // 冒泡排序
   // 1.比较数组中两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
   // 2.每一次比较,都会产生一个最大,或者最小的数字
   // 3.下一轮则可以少一次排序
   // 4.依次循环,直到结束

   // 自己写的冒泡排序
   public static void sort(int[] arr){
int temp;
       for(int i = 0; i < arr.length - 1; i++){
           for(int j = 0 ; j < arr.length - 1 - i;j++){
               // “>” 大的往后移,即从小到大 “<”从大到小
               if(arr[j] > arr[j + 1]){
                   temp = arr[j];
                   arr[j] = arr[j + 1];
                   arr[j + 1] = temp;
              }
          }
      }
  }

   // 遍历数组
   public static void search(int[] arr){
       for (int i = 0; i < arr.length; i++) {
           System.out.print(arr[i] + " ");
      }
  }
}

标签:arr,nums,int,基础,System,冒泡排序,length,数组
From: https://www.cnblogs.com/jiaxing-java/p/16913976.html

相关文章