三 数组

数组

1.数组的定义,声明,创建

 /*数组:存储一组数据相同的数据,
 在内存空间中是连续的,
 长度一旦给定就不能改变    
* 数组属于引用数据类型
数组中可以存基本数据类型,也可以存引用数据类型 * */   
public static void main(String[] args) {       
/* //数组的两种声明方式        
int [] a;//推荐使用第一种        
int b [];*/        
//数组的创建方式1:        
int [] ary0=new int[10];//动态存储,数组长度为10  没有为元素赋值，可以结合for循环进行赋值    
//数组的创建方式2;        
int [] ary1=new int[]{1,2,3,4,5};        
//数组的创建方式3        
int [] ary2={1,2,3,4,5};//静态存储,适用于已知固定数量如:一周七天,四季}}
    System.out.println(Arrays.toString(ary0));//将数组以字符串的形式输出

2.数组的索引

数组名字[索引] 例如：a[0],a[1];

//数组的索引    数组名字[索引] 例如：a[0],a[1];
//数组的索引从0开始
int [] ary1=new int[]{1,2,3,4,5};
int a=ary1[4];//数组的索引最大值值始终与数组长度差1
System.out.println(a);

3.数组的访问与迭代

/** 数组的迭代与访问* 
第一种 for循环*
第二种 增强for循环*/
int []ary4 ={1,2,3,4,5,6};
//创建for 
(int i = 0; i <ary4.length; i++) {  //for循环    
    System.out.println(ary4[i]);}
/*增强for循环:
for(数组元素的类型 临时变量名字 ：数组的名字)
{System.out.println(临时变量名字 );}*/
//临时变量的变量类型,可以与数组元素类型不同,但范围要比数组元素的类型大
for(int t: ary4) {    //从0开始,将数组元素赋值给临时变量t,直至数组元素全部输出    
    System.out.println(t);    
}

//数组的索引    数组名字[索引] 例如：a[0],a[1];
        //数组的索引从0开始
        int a=ary1[4];//数组的索引最大值值始终与数组长度差1
        System.out.println(a);

4.数组排序

三种排序方式:冒泡排序,选择排序,插入排序

//冒泡排序:每次取出相邻的两个元素进行比较,将较大的向后移动.直至所有元素比较完.
    public static void main(String[] args) {

        //冒泡排序
        int []ary1={7,6,5,4,3};
        /*          6 5 4 3 7
                    5 4 3 6 7
        *           4 3 5 6 7
                    3 4 5 6 7
        */
        for (int i = 0; i < ary1.length-1; i++) {//外层循环,控制循环的次数
            //i < ary1.length-1; -1:避免白跑一次
            for (int j = 0; j < ary1.length-1-i; j++) {//内层循环,控制比较的次数
                //j < ary1.length-1-i; [j+1]与[j]比较, -1防止数组溢出, -i避免无用的比较
                if(ary1[j]>ary1[j+1]){
                    int temp=ary1[j];
                    ary1[j]=ary1[j+1];
                    ary1[j+1]=temp;
                }
                //System.out.println(Arrays.toString(ary1)); 输出内层循环比较的过程

            }
           //System.out.println(Arrays.toString(ary1));  输出外层循环排序的过程
        }
        System.out.println(Arrays.toString(ary1));   //输出最后结果

/* 
选择排序:取出第一个元素,依次与后面的元素相比较,将最大/最小的值移到最后一位,然后依次取第2,3........个
* */
    //选择排序的第一种写法
public class selectDemo {
    //主方法!
    public static void main(String[] args) {
        //初始化
        selectDemo selectDemo=new selectDemo();
        int arr[]={11,65,43,12,34,23,45};
        selectDemo.select(arr);
    }
    public void select(int arr[]){
        int temp;
        for (int i = 0; i < arr.length-1; i++) {
            //依次取出arr[i]
            for (int j = i+1; j <arr.length ; j++) {
                //将取出的arr[i]依次与后面的比较,初始为i+1
                if (arr[j]<arr[i]){
                    //每进行一次内循环,就将比较较小的值与之交换
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
            //System.out.println(Arrays.toString(arr));
        }
        System.out.println(Arrays.toString(arr));
    }

}

 /*            选择排序的第二种写法
    * 进行内循环,将内循环的每次比较的较小值赋值给min,
    * 但不进行位置的交换,等内循环全部循环完毕后,
    * 再将最小值与外循环第i位进行位置交换*/
    public void select2(int a[]){
        int temp;
        for (int i = 0; i < a.length-1; i++) {
            int Min=i;//声明一个min用来存储内循环每次比较的较小值
            for (int j = i+1; j <a.length ; j++) {
                if (a[j]<a[Min]){
                    Min=j;//将比较的较小值赋值给min
                }
            }
            //内循环结束之后,将最小值与第i个的位置进行交换
            temp = a[i];
            a[i] = a[Min];
            a[Min] =temp;
        }
        System.out.println(Arrays.toString(a));
        
   
    //主方法!
    public static void main(String[] args) {
    //初始化
        selectDemo selectDemo=new selectDemo();
        int arr[]={11,67,43,12,34,23,45};
        selectDemo.select2(arr);
    }

//插入排序:类似打扑克牌,从第二张开始插入,小的插到大的前面,然后使其有序,直至全部插入
//插入排序的第一种写法
public static void main(String[] args) {
        int a[]={1,3,4,2};
        for (int i = 1; i < a.length; i++) {
            for (int j =i; j >0 ; j--) {
                if(a[j]<a[j-1]){

                    int temp;
                    temp=a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

 public static void main(String[] args) {
                   //   4
        int [] a = {3,2,1,4,5};
           //第一个变量记录当前要排序的那个元素
           //第二个变量记录当前所比较的位置
          int currentvalue=0;
        for (int i = 0; i < a.length-1; i++) {
              currentvalue  = a[i+1];
              int preIndex = i;//当前所比较的位置
            while(preIndex>=0&&currentvalue<a[preIndex]){
                   a[preIndex+1] = a[preIndex];
                   preIndex--;//-1
            }
                a[preIndex+1] = currentvalue;//
        }
        System.out.println(Arrays.toString(a));
    }

5.二维数组

public static void main(String[] args) {
     /*  二维数组的声明
        int [][]a;建议用第一种
        int a[][];
        二维数组的创建
        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]; 二维数组中有三个一维数组,每个一维数组的长度为5
        */
        //二维数组的遍历
        int[][] b1 = new int[][]{{1, 2,3}, {4,5,6}};
        for (int i = 0; i < b1.length; i++) {
            for (int j = 0; j < b1[i].length; j++) {
                System.out.print(b1[i][j]);}