5、JAVA数组学习

5. 数组

1. 数组概述和特点

1:二维数组(理解)

   (1)元素是一维数组的数组。

   (2)格式：

      A:数据类型[][] 数组名 = new 数据类型[m][n];

      B:数据类型[][] 数组名 = new 数据类型[m][];

      C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};

      D:数据类型[][] 数组名 = {{...},{...},{...}};

   (3)案例(掌握):

      A:二维数组的遍历

      B:二维数组的求和

      C:杨辉三角形

数组(掌握)

   (1)数组：存储同一种数据类型的多个元素的容器。

   (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。

            编号的专业叫法：索引

   (3)定义格式

      A:数据类型[] 数组名;

      B:数据类型 数组名[];

      推荐是用A方式，B方法就忘了吧。

      但是要能看懂

   (4)数组的初始化

      A:动态初始化

        只给长度，系统给出默认值

        举例：int[] arr = new int[3];

      B:静态初始化

        给出值，系统决定长度

        举例：int[] arr = new int[]{1,2,3};

        简化版：int[] arr = {1,2,3};

   (5)Java的内存分配

      A:栈 存储局部变量

      B:堆 存储所有new出来的

      C:方法区(面向对象部分详细讲解)

      D:本地方法区(系统相关)

      E:寄存器(CPU使用)

      注意：

        a:局部变量 在方法定义中或者方法声明上定义的变量。

        b:栈内存和堆内存的区别

           栈：数据使用完毕，就消失。

           堆：每一个new出来的东西都有地址

               每一个变量都有默认值

                 byte,short,int,long 0

                 float,double 0.0

                 char '\u0000'

                 boolean false

                 引用类型 null

               数据使用完毕后，在垃圾回收器空闲的时候回收。

   (6)数组内存图

      A:一个数组

      B:二个数组

      C:三个数组(两个栈变量指向同一个堆内存)

   (7)数组的常见操作

      A:遍历

        方式1：          

 public static void printArray(int[] arr) {

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

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

              }

           }

        方式2：
          

 public static void printArray(int[] arr) {

         System.out.print("[");

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

                 if(x == arr.length-1) {

                    System.out.println(arr[x]+"]");

                 }else {

                    System.out.println(arr[x]+", ");

                 }

          }

 }

      B:最值

        最大值：         

 public static int getMax(int[] arr) {

           int max = arr[0];

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

                 if(arr[x] > max) {

                    max = arr[x];

                 }

           }

        return max;
}

        最小值：
          

 public static int getMin(int[] arr) {

              int min = arr[0];

             

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

                 if(arr[x] < min) {

                    min = arr[x];

                 }

              }

             

              return min;

           }

      C:逆序

        方式1：          

          

 public static void reverse(int[] arr) {

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

                 int temp = arr[x];

                 arr[x] = arr[arr.length-1-x];

                 arr[arr.length-1-x] = temp;

              }

           }

        方式2：
          

 public static void reverse(int[] arr) {

              for(int start=0,end=arr.length-1; start<=end; start++,end--) {

                 int temp = arr[start];

                 arr[start] = arr[end];

                 arr[end] = temp;

              }

           }

      D:查表
          

 public static String getString(String[] strArray,int index) {

              return strArray[index];

           }

      E:基本查找

        方式1：         

  public static int getIndex(int[] arr,int value) {

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

                 if(arr[x] == value) {

                    return x;

                 }

              }

             

              return -1;

           }

        方式2：
          

 public static int getIndex(int[] arr,int value) {

              int index = -1;

          

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

                 if(arr[x] == value) {

                    index = x;

                    break;

                 }

              }

             

              return index;

                                }

/*

   数组:存储同一种数据类型的多个元素的容器。

  

   定义格式：

      A:数据类型[] 数组名;

      B:数据类型 数组名[];

     

   举例：

      A:int[] a; 定义一个int类型的数组a变量

      B:int a[]; 定义一个int类型的a数组变量

     

   注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。

  

   如何对数组进行初始化呢?

      A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值

      B:有几种方式呢?

        a:动态初始化 只指定长度，由系统给出初始化值

        b:静态初始化 给出初始化值，由系统决定长度

       

   动态初始化的格式：

      数据类型[] 数组名 = new 数据类型[数组长度];

     

      举例：

      int[] arr = new int[3]; 

     

   如何获取数组中的元素呢?

      通过:

        数组名[索引]

        索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。

*/

class ArrayDemo {

   public static void main(String[] args) {

      //定义一个数组

      //int[] a;

      //可能尚未初始化变量a

      //System.out.println(a);

     

      int[] arr = new int[3];

      /*

        左边：

           int:说明数组中的元素的数据类型是int类型

           []:说明这是一个数组

           arr:是数组的名称

          

        右边：

           new:为数组分配内存空间。

           int:说明数组中的元素的数据类型是int类型

           []:说明这是一个数组

           3:数组长度，其实也就是数组中元素的个数

      */

     

      System.out.println(arr); //[I@175078b 地址值。

      //我要地址值没有意义啊，我就要数据值，怎么办呢?

      //不用担心，java为你考虑到了。

      //其实数组中的每个元素都是有编号的，并且是从0开始。最大编号是数组的长度-1。

      //用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引

      //通过数组名访问数据的格式是：数组名[索引];

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

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

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

   }

}

/*

   数组的静态初始化：

      格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

      简化格式：

        数据类型[] 数组名 = {元素1,元素2,…};

     

      举例：

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

       

        简化后：

       

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

       

   注意事项：

      不要同时动态和静态进行。

      如下格式：

        int[] arr = new int[3]{1,2,3}; //错误

*/

class ArrayDemo5 {

   public static void main(String[] args) {

      //定义数组

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

     

      System.out.println(arr);

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

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

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

   }

}

/*

   数组操作的两个常见小问题：

      ArrayIndexOutOfBoundsException:数组索引越界异常

        原因：你访问了不存在的索引。

     

      NullPointerException:空指针异常

        原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

       

      作用：请自己把所有的场景Exception结尾的问题总结一下。以后遇到就记录下来。

          现象，原因，解决方案。

*/

class ArrayDemo6 {

   public static void main(String[] args) {

      //定义数组

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

     

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

  

      //引用类型的常量：空常量 null

      arr = null;

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

   }

}

/*

   数组遍历：就是依次输出数组中的每一个元素。

  

   注意：数组提供了一个属性length，用于获取数组的长度。

        格式：数组名.length

*/

class ArrayTest {

   public static void main(String[] args) {

      //定义数组

      int[] arr = {11,22,33,44,55};

     

      //获取每一个元素

      //如何获取呢?我们知道数组名结合编号(索引)就可以找到数据

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

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

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

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

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

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

     

      //虽然这种做法可以，但是不是我想要的

      //我们发现，代码的重复度很高

      //输出语句，数组名都是相同的，仅仅是索引是变化的

      //我们就可以使用循环搞定索引值

      for(int x=0; x<5; x++) {

        //x=0,1,2,3,4

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

      }

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

     

      //从0开始我们是明确的，但是为什么到5呢，我们是数了一下数组的个数

      //继续看下个数组如何遍历

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

      //而我们在很多时候，数组的元素不能靠数

      //这个时候，数组就给我们提供了一个属性：length专门用于获取数组的长度

      //格式：数组名.length 返回数组的长度

      System.out.println(arr.length);

      System.out.println(arr2.length);

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

     

      //改进第一个程序

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

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

      }

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

     

      //我们如果想要对多个数组进行遍历，每个数组的遍历我们都把代码写一遍，麻烦不

      //麻烦，所以，我们准备用方法改进。

      //用方法改进后，请调用

      printArray(arr);

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

      printArray(arr2);

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

      printArray2(arr);

   }

  
  

/*

      遍历数组的方法

     

      两个明确：

        返回值类型：void

        参数列表：int[] arr

   */

   public static void printArray(int[] arr) {

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

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

      }

   }

  

   //请看改进版本

   public static void printArray2(int[] arr) {

      System.out.print("[");

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

        if(x == arr.length-1) { //这是最后一个元素

           System.out.println(arr[x]+"]");

        }else {

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

        }

      }

   }

}

/*

   数组获取最值(获取数组中的最大值最小值)

  

   分析：

      A:定义一个数组，并对数组的元素进行静态初始化。

      B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。

      C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

      D:最后参照物里面保存的就是最大值。

*/

class ArrayTest2 {

   public static void main(String[] args) {

      //定义一个数组

      int[] arr = {34,98,10,25,67};

     

      //请获取数组中的最大值

      /*

      //从数组中任意的找一个元素作为参照物

      int max = arr[0];

      //然后遍历其他的元素

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

        //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

        if(arr[x] > max) {

           max = arr[x];

        }

      }

      //最后参照物里面保存的就是最大值。

      System.out.println("max:"+max);

      */

  

      //把这个代码用方法改进

      //调用方法

      int max = getMax(arr);

      System.out.println("max:"+max);

       

      //请获取数组中的最小值

      int min = getMin(arr);

      System.out.println("min:"+min);

   }

  

   /*

      需求：获取数组中的最大值

      两个明确：

        返回值类型：int

        参数列表：int[] arr

   */

   public static int getMax(int[] arr) {

      //从数组中任意的找一个元素作为参照物

      int max = arr[0];

      //然后遍历其他的元素

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

        //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

        if(arr[x] > max) {

           max = arr[x];

        }

      }

      //最后参照物里面保存的就是最大值。

      return max;

   }

  

   public static int getMin(int[] arr) {

      //从数组中任意的找一个元素作为参照物

      int min = arr[0];

      //然后遍历其他的元素

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

        //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。

        if(arr[x] < min) {

           min = arr[x];

        }

      }

      //最后参照物里面保存的就是最小值。

      return min;

   }

}

/*

   数组元素逆序 (就是把元素对调)

  

   分析：

      A:定义一个数组，并进行静态初始化。

      B:思路

        把0索引和arr.length-1的数据交换

        把1索引和arr.length-2的数据交换

        ...

        只要做到arr.length/2的时候即可。

*/

class ArrayTest3 {

   public static void main(String[] args) {

      //定义一个数组，并进行静态初始化。

      int[] arr = {12,98,50,34,76};

     

      //逆序前

      System.out.println("逆序前：");

      printArray(arr);

     

      //逆序后

      System.out.println("逆序后：");

      //reverse(arr);

      reverse2(arr);

      printArray(arr);

   }

  

   /*

      需求：数组逆序

      两个明确：

        返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组)

        参数列表：int[] arr

   */

   public static void reverse(int[] arr) {

      /*

      //第一次交换

      int temp = arr[0];

      arr[0] = arr[arr.length-1-0];

      arr[arr.length-1-0] = temp;

     

      //第二次交换

      int temp = arr[1];

      arr[1] = arr[arr.length-1-1];

      arr[arr.length-1-1] = temp;

     

      //第三次交换

      int temp = arr[2];

      arr[2] = arr[arr.length-1-2];

      arr[arr.length-1-2] = temp;

      */

      //用循环改进

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

        int temp = arr[x];

        arr[x] = arr[arr.length-1-x];

        arr[arr.length-1-x] = temp;

      }

   }

  

   public static void reverse2(int[] arr) {

      for(int start=0,end=arr.length-1; start<=end; start++,end--) {

        int temp = arr[start];

        arr[start] = arr[end];

        arr[end] = temp;

      }

   }

  

   //遍历数组

   public static void printArray(int[] arr) {

      System.out.print("[");

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

        if(x == arr.length-1) { //这是最后一个元素

           System.out.println(arr[x]+"]");

        }else {

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

        }

      }

   }

}

/*

   需求：数组元素查找(查找指定元素第一次在数组中出现的索引)

  

   分析：

      A:定义一个数组，并静态初始化。

      B:写一个功能实现

        遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较

        如果相等，就返回当前的索引值。

*/

class ArrayTest5 {

   public static void main(String[] args) {

      //定义一个数组，并静态初始化

      int[] arr = {200,250,38,888,444};

     

      //需求：我要查找250在这个数组中第一次出现的索引

      int index = getIndex(arr,250);

      System.out.println("250在数组中第一次出现的索引是："+index);

     

      int index2 = getIndex2(arr,250);

      System.out.println("250在数组中第一次出现的索引是："+index2);

     

      int index3 = getIndex2(arr,2500);

      System.out.println("2500在数组中第一次出现的索引是："+index3);

   }

  

   /*

      需求：查找指定数据在数组中第一次出现的索引

      两个明确：

        返回值类型：int

        参数列表：int[] arr,int value

   */

   public static int getIndex(int[] arr,int value) {

      //遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较

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

        if(arr[x] == value) {

           //如果相等，就返回当前的索引值。

           return x;

        }

      }

     

      //目前的代码有一个小问题

      //就是假如我要查找的数据在数组中不存在，那就找不到，找不到，你就对应的返回吗?

      //所以报错。

     

      //只要是判断，就可能是false，所以大家要细心。

     

     

      //如果找不到数据，我们一般返回一个负数即可，而且是返回-1

      return -1;

   }

  

   public static int getIndex2(int[] arr,int value) {

      //定义一个索引

      int index = -1;

     

      //有就修改索引值

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

        if(arr[x] == value) {

           index = x;

           break;

        }

      }

     

      //返回index

      return index;

   }

}

 

2. 创建数组和初始化

1、创建数组和初始化

  （1）声明（一维数组的声明方式有两种）

   type[]   arr_name;（推荐使用这中方式）

    type   arr_name[];

注：

  （2）声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法

  （3）声明一个数组的时候并没有数组被真正的创建。

  （4）构造一个数组，必须指定长度。

2、构建数组：

（1）创建基本类型一维数组示例：

public class Test{          public static void main(String args[]){       int[] s = null;   // 1       s = new int[10];  //2       for ( int i=0; i<10; i++ ) {                      s[i] =2*i+1;             System.out.println(s[i]);       }  //3            }     }

 

（2）创建引用类型一维数组示例：

class Man{    private int age;    private int id;    public Man(int id,int age) {       super();       this.age = age;       this.id = id;    } }   public class AppMain {    public static void main(String[] args) {       Man[] mans;         mans = new Man[10];  //1             Man m1 = new Man(1,11);       Man m2 = new Man(2,22);  //2             mans[0]=m1;       mans[1]=m2;  //3    } }

 

3、初始化

（1）静态初始化

   除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。

        int[] a = {1,2,3};

        Man[] mans = {

          new Man(1,1),

          new Man(2,2)

        };

（2）动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

        int[] a = new int[2];

          a[0]=1;

     a[1]=2;

 

（3）数组的默认初始化：

   数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a[] = new int[2];  //0,0

boolean [] b = new boolean[2];  //false,false

String[] s = new String[2];     //null, null

4、数组的界限

（1）下标的合法区间：[0, length-1]

3. 数组常见操作

数组(掌握)

   (1)数组：存储同一种数据类型的多个元素的容器。

   (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。

            编号的专业叫法：索引

   (3)定义格式

      A:数据类型[] 数组名;

      B:数据类型 数组名[];

      推荐是用A方式，B方法就忘了吧。

      但是要能看懂

   (4)数组的初始化

      A:动态初始化

        只给长度，系统给出默认值

        举例：int[] arr = new int[3];

      B:静态初始化

        给出值，系统决定长度

        举例：int[] arr = new int[]{1,2,3};

        简化版：int[] arr = {1,2,3};

   (5)Java的内存分配

      A:栈 存储局部变量

      B:堆 存储所有new出来的

      C:方法区(面向对象部分详细讲解)

      D:本地方法区(系统相关)

      E:寄存器(CPU使用)

      注意：

        a:局部变量 在方法定义中或者方法声明上定义的变量。

        b:栈内存和堆内存的区别

           栈：数据使用完毕，就消失。

           堆：每一个new出来的东西都有地址

               每一个变量都有默认值

                 byte,short,int,long 0

                 float,double 0.0

                 char '\u0000'

                 boolean false

                 引用类型 null

               数据使用完毕后，在垃圾回收器空闲的时候回收。

   (6)数组内存图

      A:一个数组

      B:二个数组

      C:三个数组(两个栈变量指向同一个堆内存)

 

 

 

 

4. 多维数组

1、多维数组可以看成以数组为元素的数组。例如：

    

2、静态初始化：

      int[][] a = {

           {1,2,3},

           {3,4},

           {3,5,6,7}

      };

      System.out.println(a[2][3]);  

3、动态初始化：

      int[][] a = new int[3][];

      //a[0] = {1,2,5};   //错误，没有声明类型就初始化

      a[0]=new int[]{1,2};

      a[1]=new int[]{2,2};

      a[2]=new int[]{2,2,3,4};

      System.out.println(a[2][3]);  

4、获取数组长度：

   a.length获取的二维数组第一维数组的长度，a[0].length才是获取第二维第一个数组长度。

   (1)元素是一维数组的数组。

   (2)格式：

      A:数据类型[][] 数组名 = new 数据类型[m][n];

      B:数据类型[][] 数组名 = new 数据类型[m][];

      C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};

      D:数据类型[][] 数组名 = {{...},{...},{...}};

/*

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

  

   格式1：

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

     

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

      n:表示每一个一维数组的元素有多少个。

     

   注意：

      A:以下格式也可以表示二维数组

        a:数据类型 数组名[][] = new 数据类型[m][n];

        b:数据类型[] 数组名[] = new 数据类型[m][n];

      B:注意下面定义的区别

        int x;

        int y;

        int x,y;

       

        int[] x;

        int[] y[];

       

        int[] x,y[];

*/

class Array2Demo {

   public static void main(String[] args) {

       //定义一个二维数组

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

       //定义了一个二维数组arr

       //这个二维数组有3个一维数组的元素

       //每一个一维数组有2个元素

       //输出二维数组名称

       System.out.println(arr); //地址值   [[I@175078b

       //输出二维数组的第一个元素一维数组的名称

       System.out.println(arr[0]); //地址值   [I@42552c

       System.out.println(arr[1]); //地址值   [I@e5bbd6

       System.out.println(arr[2]); //地址值   [I@8ee016

       //输出二维数组的元素

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

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

   }

}

/*

   格式2：

      数据类型[][] 数组名 = new 数据类型[m][];

     

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

      列数没有给出，可以动态的给。这一次是一个变化的列数。

*/

class Array2Demo2 {

   public static void main(String[] args) {

      //定义数组

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

     

      System.out.println(arr); //[[I@175078b

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

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

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

     

      //动态的为每一个一维数组分配空间

      arr[0] = new int[2];

      arr[1] = new int[3];

      arr[2] = new int[1];

     

      System.out.println(arr[0]); //[I@42552c

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

      System.out.println(arr[2]); //[I@8ee016

     

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

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

      //ArrayIndexOutOfBoundsException

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

     

      arr[1][0] = 100;

      arr[1][2] = 200;

   }

}

/*

   格式3：

      基本格式：

        数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

      简化版格式：

        数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

       

      举例：

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

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

*/

class Array2Demo3 {

   public static void main(String[] args) {

      //定义数组

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

     

      System.out.println(arr);

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

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

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

     

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

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

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

     

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

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

      //越界

      System.out.println(arr[2][1]); //错误

   }

}

/*

   需求：二维数组遍历

  

   外循环控制的是二维数组的长度，其实就是一维数组的个数。

   内循环控制的是一维数组的长度。

*/

class Array2Test {

   public static void main(String[] args) {

      //定义一个二维数组

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

     

      //请问谁代表{1,2,3}

      //arr[0]就是第一个数组

      //arr[0] = {1,2,3};

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

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

      }

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

     

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

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

      }

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

     

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

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

      }

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

     

      //用循环改进

      for(int x=0; x<3; x++) {

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

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

        }

        System.out.println();

      }

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

     

      //这个时候，注意了，3是我们根据上面的代码得出来的

      //但是，它不能针对任何的数组都可以这样

      //所以，我们应该想办法改进

      //其实，外面的这个循环的长度就是二维数组的长度

     

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

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

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

        }

        System.out.println();

      }

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

     

      //用方法改进

      //调用方法

      printArray2(arr);

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

     

      //我们再来一个列数是变化的

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

      printArray2(arr2);

   }

  
  

/*

      需求：遍历二维数组

      两个明确：

        返回值类型：void

        参数列表：int[][] arr

   */

   public static void printArray2(int[][] arr) {

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

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

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

        }

        System.out.println();

      }

   }

}

 

/*

   公司年销售额求和

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

   第一季度：22,66,44

   第二季度：77,33,88

   第三季度：25,45,65

   第四季度：11,66,99

  

   分析：

      A:把题目的数据用二维数组来表示

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

      B:如何求和呢?

        求和其实就是获取到每一个元素，然后累加即可。

      C:定义一个求和变量sum，初始化值是0。

      D:通过遍历就可以得到每一个二维数组的元素。

      E:把元素累加即可。

      F:最后输出sum，就是结果。

*/

class Array2Test2 {

   public static void main(String[] args) {

      //把题目的数据用二维数组来表示

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

     

      //定义一个求和变量sum，初始化值是0。

      int sum = 0;

     

      //通过遍历就可以得到每一个二维数组的元素。

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

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

           //把元素累加即可。

           sum += arr[x][y];

        }

      }

     

      //最后输出sum，就是结果。

      System.out.println("一年的销售额为："+sum+"万元");

   }

}

/*


   需求：打印杨辉三角形(行数可以键盘录入)

  

   1

   1 1  

   1 2 1

   1 3 3 1

   1 4 6 4 1

   1 5 10 10 5 1


   分析：看这种图像的规律

      A:任何一行的第一列和最后一列都是1

      B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

  

   步骤：

      A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。

        这个n的数据来自于键盘录入。

      B:给这个二维数组任何一行的第一列和最后一列赋值为1

      C:按照规律给其他元素赋值

        从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

      D:遍历这个二维数组。

*/

import java.util.Scanner;


class Array2Test3 {

   public static void main(String[] args) {

      //创建键盘录入对象

      Scanner sc = new Scanner(System.in);

     

      //这个n的数据来自于键盘录入。

      System.out.println("请输入一个数据：");

      int n = sc.nextInt();

     

      //定义二维数组

      int[][] arr = new int[n][n];

     

      //给这个二维数组任何一行的第一列和最后一列赋值为1

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

        arr[x][0] = 1; //任何一行第1列

        arr[x][x] = 1; //任何一行的最后1列

      }

     

      //按照规律给其他元素赋值

      //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

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

        //这里如果y<=x是有个小问题的，就是最后一列的问题

        //所以这里要减去1

        //并且y也应该从1开始，因为第一列也是有值了

        for(int y=1; y<=x-1; y++) {

           //每一个数据是它上一行的前一列和它上一行的本列之和。

           arr[x][y] = arr[x-1][y-1] + arr[x-1][y];

        }

      }

     

      //遍历这个二维数组。

      /*

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

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

           System.out.print(arr[x][y]+"\t");

        }

        System.out.println();

      }

      */

      //这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似

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

        for(int y=0; y<=x; y++) {

           System.out.print(arr[x][y]+"\t");

        }

        System.out.println();

      }

   }

}

/*

   某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，

   在传递过程中需要加密，加密规则如下：

      首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，

      最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，

      然后，把加密后的结果在控制台打印出来。

     

   题目要求：

      A:数据是小于8位的整数

        定义一个int类型的数据

        int number = 123456;

      B:加密规则

        a:首先将数据倒序

           结果 654321

        b:然后将每位数字都加上5，再用和除以10的余数代替该数字

           结果 109876

        c:最后将第一位和最后一位数字交换

           结果 609871

      C:把加密后的结果输出在控制台

     

      通过简单的分析，我们知道如果我们有办法把这个数据变成数组就好了。

      不是直接写成这个样子的：

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

       

      如何把数据转成数组呢?

        A:定义一个数据

           int number = 123456;

        B:定义一个数组,这个时候问题就来了，数组的长度是多少呢?

           int[] arr = new int[8]; //不可能超过8

           在赋值的时候，我用一个变量记录索引的变化。

           定义一个索引值是0

           int index = 0;

        C:获取每一个数据

           int ge = number%10

           int shi = number/10%10

           int bai = number/10/10%10

          

           arr[index] = ge;

           index++;

           arr[index] = shi;

           index++;

           arr[index] = bai;

           ...

*/

class JiaMiDemo {

   public static void main(String[] args) {

      //定义一个数据

      int number = 123456;

     

      //定义一个数组

      int[] arr = new int[8];

     

      //把数据中每一位上的数据获取到后存储到数组中

      /*

      int index = 0;

      arr[index] = number%10; //arr[0]=6;

      index++;

      arr[index] = number/10%10; //arr[1]=5;

      index++;

      arr[index] = mumber/10/10%10; //arr[2]=4;

      */

     

      //通过观察这个代码，我们发现应该是可以通过循环改进的

      int index = 0;

     

      while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0

        arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1

        index++;//index=1,index=2,index=3,index=4,index=5,index=6

      number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0

      }

     

      //然后将每位数字都加上5，再用和除以10的余数代替该数字

      for(int x=0; x<index; x++) {

        arr[x] += 5;

        arr[x] %= 10;

      }

     

      //最后将第一位和最后一位数字交换

      int temp = arr[0];

      arr[0] = arr[index-1];

      arr[index-1] = temp;

     

      //输出数据

      for(int x=0; x<index; x++) {

        System.out.print(arr[x]);

      }

      System.out.println();

   }

}

 

5. java八大排序

public class SortTest {

   public static void main(String[] args) {

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

      System.out.println("排序前：" + Arrays.toString(arr));

      // InsertSort.sort(arr);

      // BubbleSort.sort(arr);

      // SelectionSort.sort(arr);

      // ShellSort.sort(arr);

      // QuickSort.sort(arr);

      // MergeSort.sort(arr);

      // HeapSort.sort(arr);

      System.out.println("排序后：" + Arrays.toString(arr));

   }


   /*

    * 交换数组中的两个元素

    */

   public static void swap(int[] data, int i, int j) {

      int temp = data[i];

      data[i] = data[j];

      data[j] = temp;

   }

}

 

1、冒泡排序

/*

 * 冒泡排序基本概念是：

 * 依次比较相邻的两个数，将小数放在前面，大数放在后面。

 * 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。

 * 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，

 * 直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，

 * 将最大的数放到了最后。在第二趟：仍从第一对数开始比较

 * （因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），

 * 将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），

 * 第二趟结束，在倒数第二的位置上得到一个新的最大数

 * （其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

 */

public class BubbleSort {

   public static void sort(int[] data) {

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

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

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

                 SortTest.swap(data, j, j + 1);

           }

        }

      }

   }

       public static void swap(int[] data, int i, int j) {

      int temp = data[i];

      data[i] = data[j];

      data[j] = temp;

   }

}

2、快速排序

/*

 * 快速排序：

 * 一趟快速排序的算法是： 　　

 * 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 　　

 * 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　

 * 3）从j开始向前搜索，即由后开始向前搜索（j=j-1即j--），

 * 找到第一个小于key的值A[j]，A[i]与A[j]交换； 　　

 * 4）从i开始向后搜索，即由前开始向后搜索（i=i+1即i++），

 * 找到第一个大于key的A[i]，A[i]与A[j]交换； 　　

 * 5）重复第3、4、5步，直到 I=J；

 * (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。

 * 找到并交换的时候i， j指针位置不变。

 * 另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。）

 */

public class QuickSort {

   public static void sort(int[] data) {

      quickSort(data, 0, data.length - 1);

   }


   private static void quickSort(int[] data, int i, int j) {

      int pivotIndex = (i + j) / 2;

      // swap

      SortTest.swap(data, pivotIndex, j);


      int k = partition(data, i - 1, j, data[j]);

      SortTest.swap(data, k, j);

      if ((k - i) > 1)

        quickSort(data, i, k - 1);

      if ((j - k) > 1)

        quickSort(data, k + 1, j);


   }

   private static int partition(int[] data, int l, int r, int pivot) {

      do {

        while (data[++l] < pivot)

           ;

        while ((r != 0) && data[--r] > pivot)

           ;

        SortTest.swap(data, l, r);

      } while (l < r);

      SortTest.swap(data, l, r);

      return l;

   }

}

3、堆排序

/*

 * 堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征， 使得在当前无序区中选取最大（或最小）关键字的记录变得简单。 　　

 * （1）用大根堆排序的基本思想 　　 ① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区 　　 ②

 * 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个 记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，

 * 且满足R[1..n-1].keys≤R[n].key 　　 ③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。

 * 然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，

 * 由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，

 * 且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。 　 直到无序区只有一个元素为止。 　　

 * （2）大根堆排序算法的基本操作： 　　 ① 初始化操作：将R[1..n]构造为初始堆； 　　 ②

 * 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换， 然后将新的无序区调整为堆（亦称重建堆）。

 */


public class HeapSort {

   public static void sort(int[] data) {

      MaxHeap h = new MaxHeap();

      h.init(data);

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

        h.remove();

      System.arraycopy(h.queue, 1, data, 0, data.length);

   }


   private static class MaxHeap {


      void init(int[] data) {

        this.queue = new int[data.length + 1];

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

           queue[++size] = data[i];

           fixUp(size);

         }

      }


      private int size = 0;


      private int[] queue;


      public int get() {

        return queue[1];


      }


      public void remove() {

        SortTest.swap(queue, 1, size--);

        fixDown(1);

      }


      // fixdown

      private void fixDown(int k) {

        int j;

        while ((j = k << 1) <= size) {

           if (j < size && queue[j] < queue[j + 1])

              j++;

           if (queue[k] > queue[j]) // 不用交换


              break;

           SortTest.swap(queue, j, k);

           k = j;

        }

      }


      private void fixUp(int k) {

        while (k > 1) {

           int j = k >> 1;

           if (queue[j] > queue[k])

              break;

           SortTest.swap(queue, j, k);


           k = j;

        }

      }


   }

}

4、插入排序

/*

 * 插入排序基本思想

 * 将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例下所示： 　　

 * {{a1}，{a2，a3，a4，…，an}} 　　

 * {{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}} 　

 * {{a1(n-1），a2(n-1) ，…},{an(n-1)}} 　　

 * 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，

 * 找出插入位置，将该元素插入到有序数列的合适位置中。

 */

public class InsertSort {

   public static void sort(int[] data) {

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

        for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {

           SortTest.swap(data, j, j - 1);

        }

      }


   }

}

5、归并排序

/*

 * 归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。 　　

 * 如设有数列{6，202，100，301，38，8，1} 　　

 * 初始状态： [6] [202] [100] [301] [38] [8] [1] 比较次数 　　

 * i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ]　3 　　

 * i=2 [ 6 100 202 301 ] [ 1 8 38 ]　4 　　

 * i=3　[ 1 6 8 38 100 202 301 ] 4

 */

public class MergeSort {

   public static void sort(int[] data) {

      int[] temp = new int[data.length];

      mergeSort(data, temp, 0, data.length - 1);

   }


   private static void mergeSort(int[] data, int[] temp, int l, int r) {

      int mid = (l + r) / 2;

      if (l == r)

        return;

      mergeSort(data, temp, l, mid);

      mergeSort(data, temp, mid + 1, r);


      for (int i = l; i <= r; i++) {

        temp[i] = data[i];

      }

      int i1 = l;

      int i2 = mid + 1;

      for (int cur = l; cur <= r; cur++) {

        if (i1 == mid + 1)

           data[cur] = temp[i2++];

        else if (i2 > r)

           data[cur] = temp[i1++];

        else if (temp[i1] < temp[i2])

           data[cur] = temp[i1++];

        else


           data[cur] = temp[i2++];

      }

   }

}

6、选择排序

/*

 * 选择排序基本思路：

 * 把第一个元素依次和后面的所有元素进行比较。

 * 第一次结束后，就会有最小值出现在最前面。

 * 依次类推

 */

public class SelectionSort {

   public static void sort(int[] data) {

      for (int x = 0; x < data.length - 1; x++) {

        for (int y = x + 1; y < data.length; y++) {

           if (data[y] < data[x]) {

              SortTest.swap(data, x, y);

           }

        }

      }

   }

}

7、希尔排序

/*

 * 希尔排序：先取一个小于n的整数d1作为第一个增量，

 * 把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。

 * 先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，

 * 直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

 */

public class ShellSort {

   public static void sort(int[] data) {

      for (int i = data.length / 2; i > 2; i /= 2) {

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

           insertSort(data, j, i);

        }

      }

      insertSort(data, 0, 1);

   }


   /**

    * @param data

    * @param j

    * @param i

    */

   private static void insertSort(int[] data, int start, int inc) {

      for (int i = start + inc; i < data.length; i += inc) {

        for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {

           SortTest.swap(data, j, j - inc);

        }

      }

   }

}

/*

 * 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序 　　

 * 排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，

 * 组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1， 即所有记录放进一个组中排序为止 　　

 * 初始：d=5 　　49 38 65 97 76 13 27 49 55 04 　　

 * 49 13 　　|-------------------| 　　

 * 38 27     |-------------------| 　　

 * 65 49 　　|-------------------| 　　

 * 97 55     |-------------------| 　　

 * 76 04 　　|-------------------| 　　

 * 一趟结果 　　13 27 49 55 04 49 38 65 97 76 　　

 * d=3 　　 13 27 49  55 04 49 38 65 97 76 　　

 * 13 55 38 76 |------------|------------|------------| 　　

 * 27 04 65 |------------|------------| 　　

 * 49 49 97 |------------|------------| 　　

 * 二趟结果  13 04 49* 38 27 49 55 65 97 76 　　

 * d=1 　　13 04 49 38 27 49 55 65 97 76

 * 　　 |----|----|----|----|----|----|----|----|----| 　　 三趟结果 　　

 * 04 13 27 38 49 49 55 65 76 97

 */