method（包括各排序算法:冒泡、插入，快速排序）

最新推荐文章于 2024-04-09 11:19:06 发布

原创最新推荐文章于 2024-04-09 11:19:06 发布 · 342 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

14 篇文章

订阅专栏

本文深入讲解Java中的数据类型转换、方法声明与调用、递归算法、数组操作、方法可变参数等内容，通过实例帮助读者理解Java核心概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JAVA The 3rd day

一.各参数类型参与运算，类型的转换：

（1）char数据类型是以整数存储在内存中(范围是0~65535)；

eg:    char c=97;
       char c2='a';
       System.out.println(c);  //a
       System.out.println(c2+5);  //102

(2)byte、short、char这三种变量一旦参与运算，则编译器将运算的结果转换为int。

  eg: byte b1=1;
      byte b2=2;
      byte b3=(byte) (b1+b2);  //(b1+b2)为int型，强转为byte

（3）当给byte、short、char变量以“直接常量”的方式赋值，只要这个“直接常量”没有超过这些数据类型的范围，则编译器也是允许的。

  eg: int x=5;
      short b=6;
      byte c=2;

二.方法声明、调用：

（1）声明格式：

[修饰符1修饰符2 …]返回值类型方法名(形式参数列表){

程序代码;

[return返回值];

}

本节主要涉及到static静态方法使用。

参数包含：形式参数(形参)：在方法定义时用于接收外界输入的数据。实际参数(实参)：调用方法时实际传给方法的数据。

传递的参数分为：基本数据类型（值拷贝）；引用类型（引用参数的副本，但副本存放的是参数地址，传参调用之后值改变）

返回值：数据类型为int,无返回值;有返回值，返回值类型为该返回值的类型（格式：return表达式；跳出方法，返回结果）；如果在方法中直接写return,而没有返回值则方法结束。

（2）方法的调用：直接调用：方法名(实参列表);类名调用：类名.方法名(实参列表);

   eg:package method;
                public class ChangeNumber {
         public static void main(String[] args) {
                    int a=1;
                    System.out.println("调用changeNumber(int a)方法之前，a="+a);
                    changeNumber(a);
                    System.out.println("调用changeNumber(int a)方法之后，a="+a);
          }

       public static void changeNumber(int a){
     if(a==3){
  System.out.println("直接结束该方法");
  return;   // 直接结束方法
      }
    System.out.println("进入changeNumber(int a)方法了...a="+a);
    a+=5;
   System.out.println("在changeNumber(int a)方法改变值后，a="+a);
    }
      }

三.递推算法：***

即就是自己调用自己（条件：递归出口(结束条件)逐层递推向出口逼近）

 eg:
package recursive;
public class SumRecursive {
public static void main(String[] args) {
        int result=getSum(100);
        System.out.println(result);
}
  public static int getSum(int number){
     if(number==1){
        return 1;
     }else{
        int temp=getSum(number-1);   // 从1开始到number-1的和
        return temp+number;
    }
  }
}

四.数组：

（1）数组的声明与分配空间大小：

数据类型[ ] 数组名 = new 数据类型[大小] ;

(2) 一维数组的静态初始化：数据类型[] 数组名={初值0,初值1,…,初值n};

eg:int[] a={1,2,3,6,5};

(3)遍历数组的方式：

1.使用for循环:

for(inti=0;i<array.length;i++){

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

     }

2.foreach输出:

  for(数据类型 变量名称:数组名称){

      …

     }

    eg:for(int x:array){

         System.out.print(x+"  ");

        }

 eg:package array;
    public class ArrayDemo {
    public static void main(String[] args) {
       int[] a=new int[5];
       a[2]=23;
       a[4]=19;
       System.out.println("遍历第一个数组：");
       for(int i=0;i<a.length;i++){   // i充当了下标
       System.out.print(a[i]+"  ");
       }
    System.out.println();
    int[] b={11,22,33,44,55,66};   // 直接给数组赋值
    System.out.println("遍历第二个数组：");
      for(int i=0;i<b.length;i++){   // i充当了下标
       System.out.print(b[i]+"  ");
      }
    System.out.println();
    System.out.println("使用foreach方式遍历数组：");
       for(int x:b){
         System.out.print(x+"  ");
       }
     System.out.println();
    }
}

五.方法的可变参数：

格式：返回值类型方法名称(类型… 参数名称){

}

  eg：package array;
      public class ChangeableParam {
      public static void main(String[] args) {
              show();
              show(1,12,56,89);
              show(23,67,35,45);
        }
     public static void show(int... a){
        System.out.println("当前传递的参数个数是："+a.length);
        for (int i = 0; i < a.length; i++) {
          System.out.print(a[i]+"  ");
        }
        System.out.println();
    }
}

The 4th day

一.数组的拷贝：

System类中有一个静态方法：

格式： public static native void arraycopy(Objectsrc,int srcPos, Object dest, int destPos, int length）

  eg：
  package copy;
  public class ArrayCopy {
   public static void main(String[] args) {
     int[] a={1,2,3,4,5,6,7,8,9};
     int[] b={11,22,33,44,55,66,77,88,99};
     System.arraycopy(a,1,b,4,3);
     System.out.println("复制后的数组：");
     for (int i = 0; i < b.length; i++) {
        System.out.print(b[i]+"  ");
     }
   }
  }

二.数组排序算法:*****

（1）冒泡排序：

eg：外层循环控制比较的“趟数”，内层循环控制着当前趟的“两两比较”的次数

 package sort;
 public class BubbleSort {
    public static void main(String[] args) {
         int[] a={22,55,11,66,88,77,44,99,33};
         bubbleSort(a);
    }
    public static void bubbleSort(int[] a){
       for (int i = 1; i <=a.length-1; i++) {   // 外层循环控制比较的“趟数”
          System.out.println("开始第"+i+"趟排序");
          boolean flag=true;
          for(int j=0;j<a.length-i;j++){   // j变量是数组的索引(下标)，j也控制着当前趟的“两两比较”的次数
            if(a[j]>a[j+1]){
             int temp=a[j];
             a[j]=a[j+1];
             a[j+1]=temp;
             flag=false;
            }
          }
         System.out.println("第"+i+"趟结束");
         if(flag){   // 如果当前“趟”已经排号序，则不必进行下一趟的排序，直接跳出外层循环
           break;
         }
        System.out.println("第"+i+"趟排序结果：");
          for(int x:a){
             System.out.print(x+"  ");
          }
       System.out.println();
      }
   }
}

（2）插入排序：选择数组中其中一个数据作为指标，前面的数据与之比较，大的向后移位，使用for循环，直到所有数据按升序排好序。

  eg：package sort;
      public class InsertSort {
      public static void main(String[] args) {
          int[] a={22,55,11,66,88,77,44,99,33};
          insertSort(a);
          System.out.println("插入排序的结果：");
          for (int i = 0; i < a.length; i++) {
              System.out.print(a[i]+"  ");
          }
      }

      public static void insertSort(int[] a){
        for (int i = 1; i <=a.length-1; i++) {
           int data=a[i];  // 当前“指示灯数据”
           int j=i-1;   // 使用j变量记录“指示灯数据”的前一个数据的索引
           while(j>=0 && data<a[j]){
                a[j+1]=a[j];   // 后移“指示灯”数据前面的数据
                j--;
           }
           a[j+1]=data;
        }
      }
     }

（3）快速排序：从待排序的数据序列中任取一个数据(如第一个数据)作为分界值，比它小的数据元素放到左边，比它大的数据元素放到它的右边。然后对左右两个子序列按照上述方法进行递归排序，直到排序完成。

  eg：快速排序方法
  package sort;
  public class QuickSort {
  public static void main(String[] args) {
     int[] a={22,55,11,66,88,77,44,99,33};
     quickSort(a,0,a.length-1);
     for (int i = 0; i < a.length; i++) {
        System.out.print(a[i]+"  ");
     }
  }

  public static void quickSort(int[] array,int start,int end){
    if(start>=end){
      return;   // 结束方法
    }
    int data=array[start];   // 将起始索引执行的值作为“分界值”
    int i=start+1;  // 记录向右移动的位置（“红军”）
    int j=end;   // 记录向左移动的位置("蓝军")
    while(true){
       while(i<=end && array[i]<data){
            i++;   // 索引右移
       }
       while(j>=start+1 && array[j]>data){
           j--;   // 索引左移
       }
       if(j>i){
         int temp=array[i];
         array[i]=array[j];
         array[j]=temp;
       }else{
           break;
       }
     }
   // “蓝军”与“分界值”交换位置
   array[start]=array[j];
   array[j]=data;   
   quickSort(array,start,j-1);   // 递归调用完成“分界值”左边的排序
   quickSort(array,j+1,end);   // 递归调用完成“分界值”右边的排序
   }
}

三. 二维数组：

（1）二维数组声明：数据类型[][]数组名称=new数据类型[行的个数][列的个数];

而二维数组长度就是其行数。

（2）二维数组访问元素：数组名称[行的索引][列的索引]

（3）二维数组静态初始化：

数据类型[][]数组名称={

{元素1,元素2,....},

...

};

eg1：声明二维数组，并给其数组元素赋值：

   package twoarray;
   public class TwoArrayDemo {
      public static void main(String[] args) {
           String[][] array=new String[3][2];
           array[0][0]="春";
           array[0][1]="夏";
           array[0][2]="秋";
           array[1][0]="冬";
           array[1][1]="四季";
           for(int i=0;i<array.length;i++){   // 循环行
              for(int j=0;j<array[i].length;j++){   // 循环当前行(一维数组)的数据
                  System.out.print(array[i][j]+"  ");
              }
              System.out.println();
            }
      }
   }

eg2：静态初始化

  package twoarray;
  public class InitialTwoArray {
     public static void main(String[] args) {
          String[][] array={
                            {"Apple","Orange","Banana"},
                            {"Dog","Cat"},
                            {"Phone","Machine","Book","Java","兵法"}
                           };
          for(int i=0;i<array.length;i++){   // 循环行
             for(int j=0;j<array[i].length;j++){   // 循环当前行(一维数组)的数据
                 System.out.print(array[i][j]+"  ");
             }
             System.out.println();
          }
    }
 }