java基础5

packagecom.edu_01;

/**

 *    2.1

   二维数组：其实二维数组其实就是一个元素为一维数组的数组。

   动态初始化方式一（指定有多少个长度相同的一维数组）：

      数据类型[][] 变量名 = new 数据类型[m][n];

      m表示这个二维数组有多少个一维数组

      n表示每一个一维数组的元素个数

   需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。

   1.打印二维数组名称

   2.打印每一个一维数组

   3.不给元素赋值打印元素

   4.赋值后打印元素 

   画出内存图解

 *

 */

public classArrayArrayDemo {

   public static voidmain(String[] args) {

//    需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。

      int[][] arr =new int[3][2];

//    1.打印二维数组名称

      System.out.println(arr);//[[I@33abb81e

     

//    2.打印每一个一维数组

      System.out.println(arr[0]);//[I@4ec4d412

      System.out.println(arr[1]);//[I@5c3f1224

      System.out.println(arr[2]);//[I@30c028cc

     

//    3.不给元素赋值打印元素

      //二维数组中的第一个一位数组的0号元素

      System.out.println(arr[0][0]);//0

      System.out.println(arr[1][1]);//0

     

//    4.赋值后打印元素

      arr[1][0] = 10;

      arr[2][0] = 20;

      System.out.println(arr[1][0]);

      System.out.println(arr[2][0]);

   }

}

packagecom.edu_01;

/**

 *    2.2

   动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：

      数据类型[][] 变量名 = new 数据类型[m][];

 

   注意：

      m这个数据必须给出，后面的数据可以不给

  

   需求：定义一个有3个一维数组的二维数组

   1.给这个二维数组的每一个一维数组的元素赋值

      仅可用此种方式：

      arr[0] = new int[2];

      arr[0][0] = 1;

      arr[0][1] = 2;

     

      不能用此种方式：

     

      arr[0] = {1,2};

      arr[1] = {5,6,7};

      arr[2] = {4};   

   2.打印二维数组的名称

   3.打印二维数组中每一个一维数组的名称

   4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）

  

   画出内存图解

 *

 */

public classArrayArrayDemo2 {

   public static voidmain(String[] args) {

      //需求：定义一个有3个一维数组的二维数组,每一个一维数组的长度不固定

      int[][] arr =new int[3][];

     

      //3.打印二维数组中每一个一维数组的名称

      System.out.println(arr[0]);//null

      System.out.println(arr[1]);//null

      System.out.println(arr[2]);//null

     

      //1.给这个二维数组的每一个一维数组的元素赋值

      //arr[0] = {1,2,3};//在这里无法使用一维数组的静态初始化给二维数组中的每一个元素赋值

      //第一个一维数组有两个元素

      arr[0] = new int[2];

      arr[0][0] = 10;

      arr[0][1] = 20;

     

      //第二个一维数组，长度为3

      arr[1] = new int[3];

      arr[1][0] = 2;

      arr[1][1] = 3;

      arr[1][2] = 4;

     

      //第三个一维数组，长度为2

      arr[2] = new int[2];

      arr[2][0] = 4;

      arr[2][1] = 5;

     

      //2.打印二维数组的名称

      System.out.println(arr);//[[I@7f39ebdb

     

      //3.打印二维数组中每一个一维数组的名称

      System.out.println(arr[0]);//[I@4ec4d412

      System.out.println(arr[1]);//[I@5c3f1224

      System.out.println(arr[2]);//[I@30c028cc

     

      //4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）

      System.out.println(arr[0][0]);

      System.out.println(arr[2][0]);     

   }

}

packagecom.edu_01;

/**

 *    2.3

   二维数组的静态初始化：

      静态初始化：

      数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

 

      简化格式：

        数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

  

   需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）

   需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）

 *

 */

public classArrayArrayDemo3 {

   public static voidmain(String[] args) {

      //需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）

      int[][] arr= new int[][]{{1,2},{3,4},{5,6}};//new int[3][2];

     

      //需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）

      int[][] arr2= {{1,2},{3,4,5},{6,7,8,9}};//new int[3][];

   }

}

packagecom.edu_01;

/**

 *    2.4 二维数组的遍历：

   需求：定义一个里面有3个长度不一样的一维数组的二维数组，并遍历

 *

 */

public class ArrayArrayDemo4{

   public static voidmain(String[] args) {

      //定义一个三个长度不意义样的一位数组的二维数组，并遍历

      int[][] arr ={{1,2},{3,4,5},{6,7,8,9,0}};

     

      //利用for循环遍历二维数组

      for (int i = 0; i< arr.length; i++) {

        //拿到每一个一维数组之后，遍历一位数组中的每一个元素

        for (int j = 0; j< arr[i].length; j++) {

           System.out.print(arr[i][j]);

        }

        System.out.println();

      }    

   }

}

packagecom.edu_01;

public classArrayArrayDemo5 {

   public static voidmain(String[] args) {

      /**

       *    2.5 二维数组的求和：

        公司年销售额求和

        某公司按照季度和月份统计的数据如下：单位(万元)

        第一季度：22,66,44

        第二季度：77,33,88

        第三季度：25,45,65

        第四季度：11,66,99

       */

      //创建对应的二维数组

      int[][] arr ={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

     

      //遍历二维数组并将每一个元素的值加起来

      int sum = 0;

      for (int i = 0; i< arr.length; i++) {

        //拿到每一个一维数组之后，遍历每一个一维数组，加起来

        for (int j = 0; j< arr[i].length; j++) {

           sum+=arr[i][j];

        }

      }

      System.out.println(sum);

   }

}

packagecom.edu_02;

public class ArgsDemo{

   public static voidmain(String[] args){

      int a = 10;

      int b = 20;

      System.out.println("a:"+a+",b:"+b); //10,20

      change(a,b);

      System.out.println("a:"+a+",b:"+b); //a:10,b:20

 

      int[] arr ={1,2,3,4,5};

      change(arr);

      System.out.println(arr[1]);//4

   }

 

   public static void change(int a,int b) {

      System.out.println("a:"+a+",b:"+b); //10,20

      a = b;

      b = a + b;

      System.out.println("a:"+a+",b:"+b);//20,40

   }

 

   public static void change(int[] arr) {

      for(int x=0;x<arr.length; x++) {

        //如果数组的元素值是偶数，就变为以前的2倍。

        if(arr[x]%2==0){

           arr[x]*=2;

        }

      }

   }

  

   /**

    * 基本数据类型：

    *       在传递参数的时候，基本数据类型的值不变

    *

    * 引用数据类型：

    *       在传递参数的时候，方法会直接影响着一个引用数据类型的参数

    */

}

packagecom.edu_03;

 

public classArraySortDemo {

   public static voidmain(String[] args) {

      //使用冒泡排序给数组int[] arr= { 24, 69, 80, 57, 13 };进行排序

      //创建一个数组

      int[] arr = {24, 69, 80, 57, 13 };

     

/*    //第一次排序

      for (int i = 0; i < arr.length -1 - 0; i++) {

        //java.lang.ArrayIndexOutOfBoundsException

        //-1是为了防止数组越界，-0是为了提高比较的效率

        if (arr[i]>arr[i+1]) {

           //找一个中间变量

           int temp = arr[i];

           arr[i] = arr[i+1];

           arr[i+1] = temp;

        }

      }

      //打印数组

      printArr(arr);

     

     

      //第二次排序

      for (int i = 0; i < arr.length -1 - 1; i++) {

        //java.lang.ArrayIndexOutOfBoundsException

        if (arr[i]>arr[i+1]) {

           //找一个中间变量

           int temp = arr[i];

           arr[i] = arr[i+1];

           arr[i+1] = temp;

        }

      }

      //打印数组

      printArr(arr);

     

     

      //第三次排序

      for (int i = 0; i < arr.length -1 - 2; i++) {

        //java.lang.ArrayIndexOutOfBoundsException

        if (arr[i]>arr[i+1]) {

           //找一个中间变量

           int temp = arr[i];

           arr[i] = arr[i+1];

           arr[i+1] = temp;

        }

      }

      //打印数组

      printArr(arr);

     

     

      //第四次排序

      for (int i = 0; i < arr.length -1 - 3 ; i++) {

        //java.lang.ArrayIndexOutOfBoundsException

        if (arr[i]>arr[i+1]) {

           //找一个中间变量

           int temp = arr[i];

           arr[i] = arr[i+1];

           arr[i+1] = temp;

        }

      }

      //打印数组

      printArr(arr);*/

     

      System.out.println("--------------------");

      //使用for循环改进上面的代码

      for (int j = 0; j< arr.length-1; j++) {//外层循环控制比较的次数

        for (int i = 0; i< arr.length - 1 - j ; i++) {

           //-1是为了防止数组越界，-j是为了提高比较的效率

           if(arr[i]>arr[i+1]) {

              //找一个中间变量

              int temp =arr[i];

              arr[i] = arr[i+1];

              arr[i+1] = temp;

           }

        } 

      }

      printArr(arr);

   }

  

   //写一个方法打印数组

   public static void printArr(int[] arr){

      for (int i = 0; i< arr.length; i++) {

        System.out.print(arr[i]+"  ");

      }

      System.out.println();

   }

  

 

}

packagecom.edu_03;

 

public classArraySortDemo2 {

   public static voidmain(String[] args) {

      //使用选择排序对数组进行排序：int[] arr= { 24, 69, 80, 57, 13 };

      int[] arr = {24, 69, 80, 57, 13 };

     

/*    //第一次比较

      int x = 0;

      for (int i = x+1; i <arr.length; i++) {

        if (arr[x]>arr[i]) {

           int temp = arr[x];

           arr[x] = arr[i];

           arr[i] = temp;

        }

       

      }

      printArr(arr);

     

     

      //第二次比较

      x = 1;

      for (int i =  x+1; i < arr.length; i++) {

        if (arr[x]>arr[i]) {

           int temp = arr[x];

           arr[x] = arr[i];

           arr[i] = temp;

        }

       

      }

      printArr(arr);

     

     

      //第三次比较

      x = 2;

      for (int i =  x+1; i < arr.length; i++) {

        if (arr[x]>arr[i]) {

           int temp = arr[x];

           arr[x] = arr[i];

           arr[i] = temp;

        }

       

      }

      printArr(arr);

     

     

      //第四次比较

      x = 3;

      for (int i = x+1; i <arr.length; i++) {

        if (arr[x]>arr[i]) {

           int temp = arr[x];

           arr[x] = arr[i];

           arr[i] = temp;

        }

       

      }

      printArr(arr);*/

     

      System.out.println("--------------------------");

      //使用for循环改进上面的代码

      for (int j = 0; j< arr.length-1; j++) {

        for (int i = j+1;i < arr.length; i++) {

           if(arr[j]>arr[i]) {

              int temp =arr[j];

              arr[j] = arr[i];

              arr[i] = temp;

           }

        }

      }

      printArr(arr);

  

   }

  

   //写一个方法打印数组

      public static void printArr(int[] arr){

        for (int i = 0; i< arr.length; i++) {

           System.out.print(arr[i]+"  ");

        }

        System.out.println();

      }

 

}

packagecom.edu_04;

 

importjava.util.Arrays;

 

public class AarraysDemo{

   public static voidmain(String[] args) {

      /**

       *    三：Arrays数组工具类

        3.1 针对数组进行操作的工具类。提供了排序，转换等功能。

     

        3.2

         *成员方法：

         *      public static String toString(int[]a):把数组转成字符串

         *    public static void sort(int[] a):对数组进行排序（有重载）

       */

      //创建一个int数组，应用Arrays里面的排序方法，对数组进行排序

      int[] arr ={4,3,6,5,2};

      //利用排序方法对数组进行排序

      Arrays.sort(arr);

      printArr(arr);

     

      System.out.println("-------------------------");

      char[] chs = {'q','s','a','c','b'};

      Arrays.sort(chs);

      printArr(chs);

   }

  

   public static void printArr(int[] arr){

      for (int i = 0; i< arr.length; i++) {

        System.out.print(arr[i]+"  ");

      }

      System.out.println();

   }

  

  

   public static void printArr(char[] chs){

      for (int i = 0; i< chs.length; i++) {

        System.out.print(chs[i]+"  ");

      }

      System.out.println();

   }

 

}

packagecom.edu_04;

 

importjava.util.Arrays;

 

public classArraysDemo2 {

   public static voidmain(String[] args) {

      //public static String toString(int[]a):把数组转成字符串

      int[] arr ={1,2,4,5,5};

      //打印上面数组的字符串表示形式

      String arrStr = Arrays.toString(arr);

      System.out.println(arrStr);

     

      System.out.println("----------");

      char[] chs = {'a','d','f','g'};

      String chsStr = Arrays.toString(chs);

      System.out.println(chsStr);   

   }

}

packagecom.edu_05;

 

importjava.util.Arrays;

 

/**

 *    四：练习（运用冒泡排序和数组工具类两种方式实现）

    * 把字符串中的字符进行排序。

    * 举例：”dacgebf”

    * 结果：”abcdefg”

 *

 */

public classStringSortDemo {

   public static voidmain(String[] args) {

      //使用冒泡排序

      String s = "dacgebf";

      //转换成字符数组

      char[] chs = s.toCharArray();

      /*//使用冒泡排序对字符根据ascii码表进行排序

      for (int i = 0; i <chs.length-1; i++) {

        for (int j = 0; j <chs.length-1-i; j++) {

           if (chs[j]>chs[j+1]){

              char temp = chs[j];

              chs[j] = chs[j+1];

              chs[j+1] = temp;

           }

        }

      }*/

      //使用Arrays里面的sort()方法给字符数组进行排序

      Arrays.sort(chs);

      //打印数组

      System.out.println(Arrays.toString(chs));

     

   }

}

packagecom.edu_06;

public class Test {

   public static voidmain(String[] args) {

      //31：在main方法中写一段代码，实现在控制台输出九九乘法表。

      for (int i = 1; i< 10; i++) {

        for (int j = 1; j<= i; j++) {

           System.out.print(i+"*"+j+"="+i*j+"  ");

        }

        System.out.println();

      }

   }

}