Java数组定义、复制、排序

第四篇

·数组:

1.概念：一组相同类型的数据的组合

         数组也是一种引用类型，

2.名称：数组名称不是固定的，与存放的数据的类型有关。

    如:  存放一组int类型的数据，

          数组名称   int[]

 

          存放一组字符串数据

          数组名称   String[]

 

          存放一组Scanner类型的数据

          数组名称   Scanner[]

 

          存放一组字符类型的数据

          数组名称   char[]

3.元素的概念：数组中的每个数据，都是这个数值的元素。

4.数组的声明与初始化

    声明：元素类型[]  变量名;

           元素类型   变量名[];--不建议此写法

    变量的初始化的时机：2种

       (1)声明时直接初始化

       (2)先声明，再初始化(使用前初始化)

    数组的变量初始化：3种情况

       (1)静态初始化

          String[] names = {"A","B"};

          int[] nums = {};

       (2)动态初始化

          --规定数组长度的写法

          int[] ages = new int[length];

       其实有默认元素：

       整数类型：默认是0

       浮点数类型：默认0.0

       字符类型：默认'\u0000'

       布尔类型：默认false

       引用数据类型：默认值null

--不规定长度的写法

       int[] ages = new int[]{};

       double[] counts = new double[]{1.2,3.14};

5.数组的长度：

     即数组元素的个数

     表示方式：变量名.length;

6.数组的下标(index):

      下标从0开始，最后一个元素的下标为：length-1;

      下标范围：0~length-1

7.数组元素的访问(查看):

      通过下标进行查看

      语法:变量名[index];

 

元素的遍历(从头到尾依次查看)

   for(int i=0;i<变量名.length;i++){

    System.out.println(变量名[i]);

   }

8.数组元素的覆盖(赋值，替换)

  语法：变量名[index] = value;

9.数组间的赋值：就是指变量之间的赋值。

  通过一个变量对数组的元素进行修改，那么与之相关的变量对应的数组的元素也会发生相应变化                                         

10.数组下标越界异常：

   java.lang.ArrayIndexOutOfBoundsException

    出现的原因：访问数组元素时的下标超出了范围

    正确范围：0~length-1

    错误下标：

           变量名[-1]

           变量名[length]

 

3.引用类型之Arrays

  是数组的工具类。此类提供了很多对数组操作的功能方法

  如：

    String info = Arrays.toString(数组名);

    Arrays.toString():此方法是将数组的元素一一拼接成字符串.

    格式如下：

       "[元素1,元素2,.....元素length-1]"

 

数组的特点：一经创建，长度不可变

数组的复制

系统复制法：

       System.arraycopy(src,start1,des,start2,length);

       src:源数组，即被复制的数组名

       start1:源数组复制的开始下标

       des:目标数组，即复制到的数组名

       start2:目标数组复制的开始下标

       length:复制的长度

工具类提供的复制方法:

      元素类型[] 变量名=Arrays.copyOf(src,newLength);

      src:源数组

      newLength:新数组的长度

 

     功能解释：从src的下标为0的元素开始复制，复制到长度为newLength的新数组中，新数组存放元素的开始位置为0

 

数组的排序：

冒泡排序的基本思想：

在要排序的数组中，对当前还未排好序的范围内的全部数，自上而下(自左到右)对相邻的两个数依次进行比较和调整，让较大的往下沉(或向右移)，较小的往上冒(或向左移)。

即：每当两相邻的数比较后他们的顺序与排序要求相反时，就将他们互换。

冒泡排序的改进：

对冒泡排序的常见的改进方法是： 加入一个标志性的变量，用于标志某一轮排序过程中是否有数据交换，如果没有进行数据交换，则说明数据已经按照要求排列好，可立即结束排序，避免不必要的比较过程。

 冒泡排序的每一步详情

第一轮：找最大值

         4>5  false  {4,5,2,3,1}

         5>2  true   {4,2,5,3,1}

         5>3  true   {4,2,3,5,1}

         5>1  true   {4,2,3,1,5}--排出5

第二轮：找第二大

         4>2  true   {2,4,3,1,5}

         4>3  true   {2,3,4,1,5}

         4>1  true   {2,3,1,4,5}--排出4

第三轮：找第三大

         2>3  false  {2,3,1,4,5}

         3>1  true   {2,1,3,4,5}--排出3

         第四轮：找第四大

         2>1  true   {1,2,3,4,5}--排出2

 

简单选择排序：

基本思想如下

在要排序的数组中，选择出最小(或者最大)的一个数与第一个位置的数交换，然后再剩下的数当中再找最小(或最大)的与第二个位置的数交换依次类推，直到第n-1个元素(倒数第二个)和第n个元素(最后一个数)比较为止。

 

 

简单选择排序

原始数据 {4,5,2,3,1};

  找出最小1  与4交换  {1,5,2,3,4}

  找出最小2  与5交换  {1,2,5,3,4}

  找出最小3  与5交换  {1,2,3,5,4}

  找出最小4  与5交换  {1,2,3,4,5}

 

工具类Arrays里的排序方法：

   Arrays.sort(数组名):对基本数据类型的数组与引用类型的数组都可排序

 

二维数组

概念：数组的元素依然是数组

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

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

访问： b[0]-->{1,2}

       b[1]-->{2,3,4,5,6}

       b[2]-->{1,2,3}

 

       b[0][0] -->1

       b[0][1] -->2

       .....

       b[1][3] -->5

       b[1][4] -->6

       ...

       b[2][1] -->2

 

 

       x={ ·

          {1,2,3},

          {1,2,3},

      {4,5,6}

         }

 

 x数组的元素：都是等长的数组，类似于矩阵。

 

       y ={

       {1,2},

       {1,2,3},

       {1}

          }

 y数组的元素：不是等长的数组。

 

二维数组的初始化：

  静态初始化

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

  动态初始化

      (1)等长式初始化

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

      表示a有三个元素，每个元素都是2个长度的数组。

      (2)只规定高维数组的长度

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

      表示a有三个元素，但是都是null.

      null在使用时，需要新建数组对象(长度任意)

 

=================================================================

第五篇

方法：即功能，封装了一段逻辑代码。

方法的定义：

固定语法：

   修饰词  返回值类型  方法名(形式参数){

        逻辑代码

     }

方法的位置：

   在类体中，与main方法是并列关系，类体中可以有多个方法。

修饰词：

      (1)public--公共的

      (2)protected--受保护的

      (3)private  --私有的

       也可以不写修饰词，即默认的(default)

       static修饰词可以与上述三个连用

返回值类型：

      (1) void---无返回值类型

      (2)java语言的任意一种类型

       可以是基本数据类型，也可以是引用数据类型

方法名：

      命名时尽量做到见名知意，驼峰命名法，首字母小写

形式参数：

    用于接收调用者传入的数据。与变量的声明语法相同。

关键字return:

       作用1：结束方法逻辑

       作用2：如果返回值类型标记的是java语言类型的某一个类型名，那么return关键字后必须跟着一个此类型的数据或变量。

当方法有返回值类型时，return关键字后的数据就是此方法要返回的数据。返回给调用者。

       如：

       int num = Math.random();

       方法random()返回一个数据给main方法。main方法存入num变量中

如:

   reg1:

    

     public static void sum(){

    int a = 3;

    int b = 5;

    System.out.println(a+b);

    [return;]---返回值类型处写void时，return可有可无；

     }

 

   reg2: 计算两个整数a和b的和

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

    int sum = a+b;

    System.out.println(sum);

     }

 

PS:  方法定义期间，就是制定逻辑流程模板。

 

   reg3:

       public static int sum(){

       int a = 3;

       int b = 5;

       int sum = a+b;

       return sum;

       }

   reg4:

       public static int sum(int a,int b){

       int sum = a + b;

       return sum*3;

       }

 

方法的调用，即使用

     reg1如何使用：

     main(String[] args){

    sum();

     }

     reg2如何使用：

     main(String[] args){

        /*

      调用者main 在使用sum(int a,int b)时，需要给形式参数赋值，赋的值叫实际参数

    */

    int x = 1;

    int y = 2;

    sum(x,y);

     }

 

reg3如何使用

    main(String[] args){

    int n = sum();

     }

 

reg4如何使用

     main(String[] args){

    int m = 10;

    int n = 20;

    int s = sum(m,n);

     }

   

总结：

   调用方法：

    无返回值时：

       方法名(有参就传参);

    有返回值时：

       返回值类型 变量=方法名(有参就传参);