Java数组:什么是数组，数组声明和创建，下标越界，数组的使用，二维数组，Arrays类，冒泡排序，稀疏数组

//数组的定义
//数组是相同类型数据的有序集合.
// 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
//其中,每一个数据称作-个数组元索,每个数组元索可以通过-个下标来访问它们
public class Demo1 {
    //变量的类型 变量的方法   =   变量的值
    //数组类型
    public static void main(String[] args) {
        int[] num; //1.声明一个数组
        num = new int[10];//创建一个数组
  //3.给数组元素中赋值
        num[0]= 1;
        num[1]= 2;
        num[2]= 3;
        num[3]= 4;
        num[4]= 5;
        num[5]= 6;
        num[6]= 7;
        num[7]= 8;
        num[8]= 9;
        num[9]= 10;
        //计算所有元素的和
        int sum = 0;
        //获取数组长度
         for (int i = 0; i<num.length;i++){
             sum = sum+ num[i];
             System.out.println ("总和为:"+sum);
         }
        //System.out.println (num[9]);

    }

}
//数组的四个基本特点
   //其长度是确定的，数组一旦槐创键，它的大小就是不可以改变的。。
   //其元索必须是相同类型,不允许出现混合类型。
   //数组中的元素可以是任何数据类型，包括基本类型和引用类型。
   //数组变量属引用类型，数组也可以看成是对象，
   // 数组中的每个元素相当于该对象的成员变量。
   // 数组本身就是对象，Java中对象是在堆中的，
   // 因此数组无论保存原始类型还是其他对象类型，
   // 数组对象本身是在堆中的
    public static void main(String[] args) {
        //静态初始化:创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8};
       // Man [] mans = {new Man(),new Man ()};
        System.out.println (a[0]);
        //动态初始化:包含默认初始值
        int [] b = new int[10];
        b[0]=10;
        b[1]=10;
        b[2]=10;
        b[3]=10;
        System.out.println (b[0]);
        System.out.println (b[1]);
        System.out.println (b[2]);
        System.out.println (b[3]);
    }
}

//下标越界
         //for (int i = 0; i<a.length;i++){
            // System.out.println (a[i]);
        // }
  //数组边界
       //下标的合法区间: [0, length-1],如果越界就会报错;
        //public static void main(String[] args) { int[] a=new int[2];
        //System. out . print1n(a[2]);
        //ArrayIndexOutOfBoundsException :数组下标越界异常!
        //小结:
        //数组是相同数据类型(数据类型可以为任意类型)的有序集合
        //数组也是对象。数组元素相当于对象的成员变量
        //>数组长度的确定的，不可变的。如果越界，则报: ArrayIndexOutofBounds
//数组的使用
    //普通for循环
   //for-Each循环
   //数组作方法入参
   //数组作返回值

import javax.crypto.spec.PSource;
import javax.swing.plaf.basic.BasicOptionPaneUI;

public class Man {
    public static void main(String[] args) {
       int [] argsa = {1,2,3,4,5,6};

        //打印全部的数组元素
       for (int i = 0; i<argsa.length; i++){
           System.out.println (argsa[i]);
   }
        System.out.println ("==============");
     //计算所有元素的和
       int sum = 0;
       for (int i = 0; i<argsa.length; i++){
       sum += argsa[i];
       }
        System.out.println ("sum="+sum);
        //查找最大元素
        System.out.println ("===============");
         int out = argsa[0];
          for (int i = 1; i<argsa.length; i++){
              if(argsa[i]>out){
                out = argsa[i];
              }
          }
        System.out.println ("out="+out);
        //以上这就是一些数组的基本使用
           }
        }
//for-Each循环
public class Demo4 {
    public static void main(String[] args) {
        int[] argsa = {1, 2, 3, 4, 5, 6};

        //JDK1.5  没有下标
        //  for (int i : argsa) {
        //   System.out.println (i);
        //}

        //dayin (argsa);
        int[] reverse = reverse (argsa);
        dayin (reverse);

    }
    //数组作返回值
    //反转数组
    public static int[] reverse(int[] argsa) {
        int[] serult = new int[argsa.length];
        //反转的操作
        //一个for循环定义了两个变量的循环
        for (int i = 0, j = serult.length - 1; i < argsa.length; i++, j--) {
            serult[j] = argsa[i];
        }

        return serult;
    }
    //打印数组元素
    //数组作方法入参
    public static void dayin(int[] argsa) {
        for (int i = 0; i < argsa.length; i++) {
            System.out.println (argsa[i] + " ");
        }
    }

}
       //}

   // }
//}
 //多维数组
    //多维数组可以看成是数组的数组，比如二=维数组就是一个特殊的- -维数组,
   // 其每-个元素都 -个- -维数组。
   //二维数组
   //int a[][] = new int[2][5];
   //解析:以上二维数组a可以看成一个两行五列的数组。◆思考:多维数组的使用?
   //num[1] [0];
    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 (array[i]);
        }
        //二维数组
        System.out.println (array[2][0]);
       System.out.println (array[2][1]);
        dayin (array[0]);
    }
    //打印数组元素
    public static void dayin(int[] argsa) {
        for (int i = 0; i < argsa.length; i++) {
            System.out.println (argsa[i] + " ");
        }
    }
}
import java.util.Arrays;

public class 冒泡排序 {
    public static void main(String[] args)  {
     int [] a = {1,2,4,6,7,8,9};
     int [] sort = sort (a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println (Arrays.toString (sort));
    }
  public  static int[] sort(int[] array){
      //临时变量
    int temp = 0;
    //外层循环，判断我们这个要走多少次
      for (int i = 0; i <array.length-1; i++) {
          boolean flag = false; //通过flag标识位减少没有意义的比较
          //内层循环,比较判断两个数，如果第一个数，比第二个数大，则交换位置
          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;
                   flag = true;
               }
          }
         if(flag==false){
           break;
         }
      }
    return array;
    }
}
public class 稀疏数组 {
    public static void main(String[] args) {
        //创建一个二维数组11*11 0：没有棋子, 1.黑棋  2.白棋
        int[][] args1 = new int[11][11]; //里面都是0不有赋值
        //现在给他赋个值
        args1[1][2] = 1;
        args1[2][3] = 2;
        args1[3][4] = 3;
        //输出原始的数组
        System.out.println ("输出原始的数组");
        for (int[] ints : args1) {
            for (int anInt : ints) {
                System.out.print (anInt + "\t");
            }
            System.out.println ();
        }
        System.out.println ("====================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0; //我们首先让他为0吧,最开始是没有的
        // 然后遍历一下
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (args1[i][j] != 0) {  //如果这个棋盘中的args1
                    // 他的i或者他的j,就是不等于0的时候，说明他不是保存的0
                    sum++;
                    //然后sum++,计算里面有多少个值
                }
            }
        }
        System.out.println ("有效值的个数:" + sum);
        //创建一个稀疏数组的数组
        int[][] args2 = new int[sum + 1][3]; //3列
        //赋值
        args2[0][0] = 11;
        args2[0][1] = 11;
        args2[0][2] = sum; //就是记录到这
        //遍历二维数组, 将非零的值，存放稀疏数组中
        int count = 0;
        for (int i = 0; i < args1.length; i++) {
            for (int j = 0; j < args1[i].length; j++) { //然后遍历args1每一个i的值的
                // length,相当于把里面的值也拿出来了
                //获取他的值
                if (args1[i][j] != 0) { //args1[i][j]不等于0,就记录到稀疏数组中
                    count++;
                    args2[count][0] = i;  //在第0行，第一个数字
                    args2[count][1] = j;
                    args2[count][2] = args1[i][j];//值
                }
            }
        }
        //输出稀疏数组
        System.out.println ("稀疏数组");
        // 循环
        for (int i = 0; i < args2.length; i++) {
            //把每个值打印过来
            System.out.println (args2[i][0] + "\t" +
                    args2[i][1] + "\t" +
                    args2[i][2] + "\t");
        }
        System.out.println ("==================");
        System.out.println ("还原");
        //1.读取稀疏数组的值
        int[][] args3 = new int[args2[0][0]][args2[0][1]];
        //2.给其中的元素还原他的值
        for (int i = 1; i < args2.length; i++) {
            //取出里面的值
            args3[args2[i][0]][args2[i][1]] = args2[i][2];  //当前的值赋给现在的值

        }
        //3.打印还原
        System.out.println ("输出还原的数组");
        for (int[] ints : args3) {
            for (int anInt : ints) {
                System.out.print (anInt + "\t");
            }
            System.out.println ();
        }
    }
}