JavaSE---数组

数组

数组是相同数据类型元素的集合
数组是对象，里面可以有指定长度个连续空间
创建时必须指定长度
数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。
数组的长度一旦声明不能再改动。

数组的声明

数组创建的三种方式：

//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值
    int[] ary0 = new int[10];//动态创建数组（没有为元素赋值，可以结合for循环进行赋值）
//声明数组并分配内存，同时将其初始化
    int[] ary1 = new int[]{1, 2, 3, 4, 5};
//与前一种方式相同，仅仅只是语法相对简略
    int[] ary2 = {1, 2, 3, 4, 5};//静态创建数组，在创建的时候，即为每个元素赋初值
	int [] b1 = new int []{1,2,3,4,5,6,7};
	System.out.println(b1.length);//数组的长度length

数组的遍历

/*
数组名字[索引]    例如：a[0],a[1];
数组的索引(编号)从0开始。
索引的数据类型是整型
索引最大值和数组长度始终差1
*/
int  []b1=new int[10];
//普通for循环
for(int i=0;i<b1.length;i++){
    System.out.println(b1[i]);
}//b1.length=10,b1的长度为10，数组从b1[0]开始，到b1[9]结束
System.out.println(Arrays.toString(b1));//数组直接输出

//增强for循环
for(int s:b1){//用s接住数组b1里的每一个元素
    System.out.println(s);
}

冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素是最大的数；

3. 针对所有的元素重复以上的步骤

4. 排序完成

   import java.util.Arrays;
   
   //冒泡排序
   public class Sort {
       public static void main(String[] args) {
           int[] array = new int[]{1, 34, 2, 3, 46, 23, 53, 12, 26, 0};
           for (int i = 0; i <array.length-1 ; i++) {//外层循环表示趟数
               boolean a=true;//默认有序
               for (int j = 0; j < array.length-1-i; j++) {
                   if(array[j]>array[j+1]){
                       int temp=array[j];
                       array[j]=array[j+1];
                       array[j+1]=temp;
                       a=false;//发生交换，说明无序
                   }
               }
               System.out.println("第"+i+"趟");
               System.out.println(Arrays.toString(array));
           }
           System.out.println("排序后："+Arrays.toString(array));
       }
   }
   

选择排序

选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到
排序的目的。

假定第一个为最小，作为索引，之后的每一个与其比较，如果比它小就交换，重复此步骤，直至排序完成

import java.util.Arrays;

//选择排序
public class SelectSort {
    public static void main(String[] args) {
        int[] array = new int[]{1, 31, 7, 29, 48, 34, 0, 2, 48, 27};
        for (int i = 0; i < array.length-1; i++) {//外层循环表示趟数
            int n =i;//先假定最小值的数组索引是0；
            int temp=array[i];//假定数组的第一个元素是最小值
            for (int j = i+1; j < array.length; j++) {//第一个数已经假定是最小值，所以从第二个数开始遍历
                if(array[j]<temp){//说明假定的最小值 并不是最小
                     temp=array[j];
                     n=j;
                }
                }
            if(n!=i){
                array[n]=array[i];
                array[i]=temp;

            }
            System.out.println("第"+i+"趟");
            System.out.println(Arrays.toString(array));
        }
    }
}

插入排序

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5

//插入排序
public class InsertSort {
    public static void main(String[] args) {
        int[] array = new int[]{1, 31, 7, 29, 48, 34, 0, 2, 48, 27};
        for (int i = 0; i < array.length-1; i++) {
            int wait = array[i+1];//从未排序的元素中取出一个元素，待排序
            int j = i;
            for (; j >=0&&array[j]>wait; j--) {//用wait与已排序的元素比较
                array[j+1]=array[j];
                //wait小，把大的元素往后挪，插入wait
            }
            array[j+1]=wait;
            System.out.println("第"+i+"趟");
            System.out.println(Arrays.toString(array));
        }
    }

二维数组

二维数组的定义：
数组的数组—二维数组的每一个元素是一个一维数组
例如：int [][]a = {{1,2,3},{1,2,3},{1,2,3}};

//数组创建
int [][]a = new int[][]{{1,2,3},{1,2,3},{1,2,3}};
int [] [] b  = {{1,2,3},{1,2,3},{1,2,3}};
int [][] c = new int[3][5];
int[][] arr = new int[3][5];
//定义了一个整型的二维数组 ,这个二维数组有3个一维数组,每一个一维数组包含5个元素.

二维数组的遍历

 int [][] b1 = new int [][]{{1,2},{3,4}};
	for(int i =0;i<b1.length;i++){
	     for(int j =0;j<b1[i].length;j++){
		System.out.print(b1[i][j]);
                          }
               }