Java数组/冒泡排序

一. 什么是一维/二维数组：

一维数组：

官方：根据定义，数组是相同类型数据的集合。

解释：大家应该都知道台球斯诺克（是有编号的(添加想像)）吧，咱们可以把台球的桌子看作一个集合，而里面的球咱们看作是一个一个的元素(球的编号)。 

二维数组：

解释：我的理解它就是嵌套数组，大家可以把二维数组想成咱们普通的台球(花球1，2，3，4/纯球1，2，3，4)，而里面的球分为一个两种，每种球都有编号(花球{1，2}，{3，4}，纯球{1，2}，{3，4})；自己想象🤣。

二.  声明数组（一维数组）：

//数组类型  数组名  []; //C语言书写形式，Java也有，也可以用 
String str[];
//数组类型  [] 数组名;  //这种方式是Java书写形式
String[] str;

三.  案例写几个：

3.1）案例一：

public class An_array_of_Laugh {
    public static void main(String[] args) {　　　　　 //String[] aegs  它就是一个数组声明哦
        int[] a = new int[]{1,2,3,4,5,6,7,8,9,10};   　//声明数组后直接初始化；
        int sum = 0;                                   //求一下他们的合
        for (int i =0; i<a.length;i++){　　　　　　　// 解释：a.length是上面声明数组的长度 且数组只认下标；
            sum = sum+a[i];
        }
        System.out.println(sum);
    }
}

3.2）案例二：

public class An_array_of_Laugh {
    public static void main(String[] args) {
        int[] a = new int[10];           　　　　　　//声明数组  且说明数组长度   可以认为，一个萝卜一个坑，我现在挖了10个坑，所以它只能放10个元素；
        int sum = 0;
        a[0] = 1;                        　　　　　　//给数组的各个下标赋值；
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;
        a[5] = 6;
        a[6] = 7;
        a[7] = 8;
        a[8] = 9;
        a[9] = 10;
        for (int i =0; i<a.length;i++){
            sum = sum+a[i];
        }
        System.out.println(sum);
    }
}

3.3）案例三：

public class An_array_of_Laugh {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9,10};　　　　　　//声明直接赋值
        int sum = 0;
        for (int i =0; i<a.length;i++){
            sum = sum+a[i];
        }
        System.out.println(sum);
    }
}

注意：数组已但声明后，它的长度就已经定死了(可以认为length已经给声明的数组打上了标签)，没办法改变，但是里面的元素是可以随意改的(但必须满足声明时候的“类型”)；

四.  实例运行说明：新手一般都是用的案例二，咱们用二来做

4.1）第一种：

public class An_array_of_Laugh {
    public static void main(String[] args) {
        int[] a = new int[10];
        int sum = 0;
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;
        a[5] = 6;
        a[6] = 7;
        a[7] = 8;
        a[8] = 9;
        a[9] = 10;
        //for循环看好了哦，新手应该很感兴趣🤣
        for (int i =0; i<a.length;i++){
            sum = sum+a[i];
        }
        System.out.println(sum);
    }
}

输出结果：

4.2）第二种

public class An_array_of_Laugh {
    public static void main(String[] args) {
        int[] a = new int[10];
        int sum = 0;
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;
        a[5] = 6;
        a[6] = 7;
        a[7] = 8;
        a[8] = 9;
        a[9] = 10;
        for (int i =0; i<=a.length;i++){
            sum = sum+i;//写的不一样但是结果一样
        }
        System.out.println("我的长度是："+ a.length);
        System.out.println("我的总合是："+ sum);
    }
}

输出结果：

五.  补充：冒泡排序等

5.1）补充1：

public class An_array_of_Laugh {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6};
        System.out.println("\n=============我是取数组的下标================");
        //循环数组所有元素，取出下标
        for (int i =0; i<a.length;i++){
            System.out.print(i);
        }
        System.out.println("\n=========我是循环数组全部值的第一种============");
        //循环数组所有元素，第一种
        for (int i =0; i<a.length;i++){
            System.out.print(a[i]);
        }
        System.out.println("\n=========我是循环数组全部值的第二种============");
        //循环数组所有元素，第二种
        for( int ii : a )
        {
            System.out.print(ii);
        }
        System.out.println("\n=============我是取数组的的最大值================");
        //循环数组所有元素，求最大值
        int max = a[0];
        for (int i =0; i<a.length;i++){
            if(a[i]>max){
                max=a[i];
            }
        }
        System.out.print(max);
        System.out.println("\n=============我是取数组的的最小值================");
        //循环数组所有元素，求最小值
        int min = a[0];
        for (int i =0; i<a.length;i++){
            if(a[i]<min){
                min=a[i];
            }
        }
        System.out.print(min);
        System.out.println("\n=============排序：从大到小排序！================");
        Big_to_small(a);
        for(int i:a){
            System.out.print(i +"\t");
        }
        System.out.println("\n=============排序：从小到大排序！================");
        small_to_Big(a);
        for(int i:a){
            System.out.print(i +"\t");
        }
    }


    //排序方法
    //由大到小排序   反之也可以由小到大
    public static void Big_to_small(int []a){
        int temp;
        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a.length;j++){
                if(a[i]<a[j]&&i<j){
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    continue;
                }else{
                    continue;
                }
            }
        }
    }
    //由小到大排序   反之也可以由大到小
    public static void small_to_Big(int []a){
        for(int i=0;i<a.length-1;i++)
        {
            for(int y=i+1;y<a.length;y++)
            {
                if(a[i]>a[y])
                {
                    int temp = a[i];
                    a[i] = a[y];
                    a[y] = temp;
                }
            }
        }
    }
}

输出结果：

5.2）补充2：Arrays类使用(常见)

import java.util.Arrays;

public class TwoArray_Laugh {
    public static void main(String[] args) {
        int[] a = {1,3,721,458,32,6};
        int[] b = {1,3,721,458,32,6};
        System.out.println("我是原样输出："+Arrays.toString(a));
        //判断像个数组是否相等    这个代码块放置位置很重要   看上面两个数组   数组的元素位置一样 则输出相等
        if(Arrays.equals(a,b)){
            System.out.println("两个数组相等："+"我是数组a"+Arrays.toString(a)+";"+"我是数组b"+Arrays.toString(b));
        }else {
            System.out.println("两个数组不等");
        }
        //内置方法  从小到大排序   Arrays.sort(a);   解释：Arrays.sort()  内置方法  a：数组
        Arrays.sort(a);
        System.out.println("我是排序输出："+Arrays.toString(a));
        //判断像个数组是否相等    这个代码块放置位置很重要   看上面两个数组   数组的元素位置一样   但是经过Arrays.sort()后重新排列了a    所有则输出不等
        if(Arrays.equals(a,b)){
            System.out.println("两个数组相等");
        }else {
            System.out.println("两个数组不等："+"我是数组a"+Arrays.toString(a)+";"+"我是数组b"+Arrays.toString(b));
        }
        //我是选择替换 fromindex：等于  toindex：小于   fromindex<=  元素下标  <toindex
        Arrays.fill(a,2,5,111);
        System.out.println("我是选择替换："+Arrays.toString(a));
        //替换，把用Arrays.fill(a,101) 后面写的数字来替换a数组里面的所有元素都为101
        Arrays.fill(a,101);
        System.out.println("我是替换输出："+Arrays.toString(a));
    }
}

输出结果：

5.3）经典排序：冒泡排序；解释：通俗易懂就是逐个比较，然后更换位置;

解释：重点：例子：有三个变量  int i = 2；int u = 3；int y = 0；是这样替换的，i和u比较；u大于i；所以他们中间有一个替换的过程，我们就需要y来完成；比如：先让 y = i；再是 i = u；然后 u = y；这就ok了；

import java.util.Arrays;

public class TwoArray_Laugh {
    public static void main(String[] args) {
        int[] a={4,2,3,6,5};
        System.out.println("我是排序前的数组："+Arrays.toString(a));
        for (int i=0;i<a.length-1;i++){
            for (int j=0;j<a.length-1-i;j++){
                int temp = 0;
                if (a[j]>a[j+1]) {
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        System.out.println("我是排序后的数组："+Arrays.toString(a));
    }
}

输出结果：

六.  声明数组（二维数组）：

//类型  名字 [][]     //来自C的传承🤣 
int a[][];
//类型 [][] 名字      //Java的惯写 
int [][] a;

七.  案例写几个：

7.1）案例一：

public class TwoArray_Laugh {
    public static void main(String[] args) {
        int[][] a = {{1,2},{2,4},{3,6}};    //声明并赋值
        for (int []b:a) {                             
            for (int c : b){
                System.out.printf("%d\t",c); //输出
            }
            System.out.println("\t");           //添加 table
        }
    }
}

7.2）案例二：

public class TwoArray_Laugh {
    public static void main(String[] args) {
        //初始化一个能存两行两列的数组   当然两行三列也可以  二维数组可以和多维数组一起理解
        int[][] a = new int[2][2];

        a[0][0]  = 10;
        a[0][1]  = 20;

        a[1][0]  = 40;
        a[1][1]  = 50;
        for (int []b:a) {

            for (int c : b){
                System.out.printf("%d\t",c);
            }

            System.out.println("\t");
        }
    }
}

八.  实例运行说明：

8.1）第一种：

public class TwoArray_Laugh {
    public static void main(String[] args) {
        int[][] a = {{1,2},{2,4},{3,6}};
        for (int []b:a) {

            for (int c : b){
                System.out.printf("%d\t", c);
            }
            System.out.println("\t");
        }
    }
}

输出结果：

8.2）第二种：

import java.util.Arrays;

public class TwoArray_Laugh {
    public static void main(String[] args) {
        int[][] a = {{1,2},{2,4},{3,6}};
        for (int []b:a) {
            System.out.println("我是带有中括号的：" + Arrays.toString(b));
        }
    }
}

输出结果：

posted @ 2021-10-18 17:39  Laugh"  阅读(104)  评论(0)  编辑  收藏  举报