Java（学习笔记三，kk自用）_java什么是kk-CSDN博客

本文链接：https://blog.csdn.net/kk123esw/article/details/88796945

实参名与形参名可以相同，也可以不同。
方法的重载：在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义，（其中返回值不能作为重载的条件！！！！而且必须在同一个类中！！！！）如:

public static void method(int a){...}
public static void method(char c){...}

数组是存储相同数据类型值的变量的集合


//函数调用输出左三角形
/*
package kk;
import java.util.*;

public class hello_world{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num =input.nextInt();
        printStar(num);

    }


    public static void printStar(int line){
        for(int i=1;i<=line;i++){
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }
};*/
//

//函数调用判断闰年
/*
package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args){
        boolean bool=isRunYear(2000);
        if(bool){
            System.out.println("闰年");

        }else
            System.out.println("平年");
    }

    public static boolean isRunYear(int year){
        if(year%4==0&&year%100!=0||year%400==0){
            return true;

        }else
            return false;
    }

};*/
//方法的重载
/*
package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args){
        int result=add(10,20);


    }
    public static int add(int a,int b){
        return a+b;

    }
    public static float add(float a,float b){
        return a+b;

    }
};*/

//数组
/*
package kk;
import java.util.*;


public class hello_world{
    public static void main(String[] args) {
        int[] nums = new int[5];//第一种声明方式
        int[] nums1 = new int[]{1, 2, 3, 4, 5};//第二种声明方式
        int[] nums2 = {1, 2, 3, 4, 5};

        System.out.println(nums.length);//求数组的长度
        for (int x : nums1) {        //foreach方法遍历（JDK1.5之后新增的特性）
            System.out.print(x + " ");
        }

    }
};*/

//JDK1.5可变参数
//可变参数只能是参数列表中的最后一个
//可变参数作为数组使用
package kk;
public class hello_world{
    public static void main(String[] args){
        System.out.println(add(2,3));
        System.out.println(add(2,3,5));

    }


    public static int add(int x,int... args){
        int sum=x;
        for(int i=0;i<args.length;i++)
            sum+=args[i];
        return sum;

    }
};

使用数组要注意的问题：

空指针异常（当一个变量为null时，我们去调用了该变量的属性和方法）
//java.lang.NullPointerException
数组越界异常
//java.lang.ArrayIndexOutOfBoundsException

内存分析
栈内存：用于存储局部、临时变量（基本数据类型）和引用变量 <大小固定>
堆内存：数组是引用类型，会存放在堆内存中<大小不固定>


//猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数
/*
package kk;
import java.util.Scanner;
import java.util.Random;    //生成随机数，注意，是伪随机数
public class hello_world{
    public static void main(String[] args)
    {
        int[] nums=new int[5];
        int len=nums.length;
        Random r=new Random();  //创建一个可以生成随机数的工具
        for(int i=0;i<len;i++){
           nums[i]= r.nextInt(50);  //生成一个50以内的数


        }
        Scanner input=new Scanner(System.in);
        System.out.println("请输入你要猜的数:(50以内)");
        int userNum=input.nextInt();
        boolean flag=false;
        for(int x:nums){
            if(userNum==x){
                flag=true;
                break;
            }

        }
        if(flag)
            System.out.println("恭喜你，猜对了！");
        else
            System.out.println("对不起，没猜对！");
    }

};
*/

//打印字符三角形
/*
package kk;
import java.util.*;
public class hello_world {
    public static void main(String[] args) {
        char cs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        for (int i = 1; i <= cs.length; i++) {
            for (int j = i; j < cs.length; j++)
                System.out.print(" ");
            for (int j = 1; j <= 2 * i - 1; j++)
                System.out.print(cs[i - 1]);
            System.out.println();
        }

    }

};
*/

讨论：
关于不使用中间变量的两数交换：

异或运算
加减运算

早期为了减少中间变量对计算机内存的占用，采用中间的方法来交换数据。其实这种交换并不完美，如果交换的两个数都很大，可能会内存溢出。在现在的开发中建议使用中间值来交换数值。

//关于不使用中间变量进行两数交换
package kk;
import java.util.*;
public class hello_world{
  public static void main(String[] args)
  {
      //第一种方法
      int x=10;
      int y=15;
      System.out.println("x="+x+"y="+y);
      x=x^y;
      y=x^y;
      x=x^y;
      System.out.println("x="+x+"y="+y);


      //第二种方法
      int a=10;
      int b=15;
      System.out.println("a="+a+"b="+b);
      a=a+b;
      b=a-b;
      a=a-b;
      System.out.println("a="+a+"b="+b);

  }

};

几种排序算法详解：

冒泡排序

//冒泡排序(是一种稳定的排序算法)
//稳定是指，相同数据的排序的前后位置不发生变化

package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args){
        int[] nums={34,4,56,17,90,65};//待排序的数列

        /*冒泡排序过程
        34 4 56 17 90 65
        4 34 17 56 65 90 //第一轮比较5次
        4 17 34 56 65    //第二轮比较4次
        4 17 34 56       //第三轮比较3次
        4 17 34          //第四轮比较2次
        4 17             //第五轮比较1次

       */

        //外循环控制轮数
        for(int i=0;i<nums.length-1;i++)//比较轮数等于数列的长度-1
        {
            for(int j=0;j<nums.length-1-i;j++) {
                if(nums[j]>nums[j+1]){
                         nums[j]=nums[j]+nums[j+1];
                         nums[j+1]=nums[j]-nums[j+1];
                         nums[j]=nums[j]-nums[j+1];
                }
            }
        }
        for(int n:nums)
        {
            System.out.println(n);
        }
    }
};

选择排序


//选择排序(是不稳定的排序算法)
/*每一趟从待排序的数据元素中选出最小(或最大)的一个元素，
    顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
*/

/*
34 4 56 17 90 65
4 34 56 17 90 65 //第一轮比较5次
4 17 56 34 90 65 //第二轮比较4次
4 17 34 56 90 65 //第三轮比较3次
4 17 34 56 90 65 //第四轮比较2次
4 17 34 56 65 90 //第五轮比较1次
*/
package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args)
    {
        int[] nums={34,4,56,17,90,65};//待排序的数列
        int minIndex=0;//用于记录每次比较的最小值的下标
        //控制轮数
        for(int i=0;i<nums.length-1;i++){
            minIndex=i;//每轮假设一个最小值下标
            for(int j=i+1;j< nums.length;j++){
                if(nums[minIndex]>nums[j]){
                    minIndex=j;
                }

            }
            //判断需要交换的数的下标是否为自己
            if(minIndex!=i)
            {
                nums[minIndex]=nums[minIndex]+nums[i];
                nums[i]=nums[minIndex]-nums[i];
                nums[minIndex]=nums[minIndex]-nums[i];
            }


        }
        for(int x:nums)
            System.out.println(x);
    }
};

直接插入排序：


//直接插入排序算法
/*
从后向前找到合适的位置后插入
*/
/*
package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args) {
        int[] nums={34,4,56,17,90,65};//待排序的数列
        //控制比较的轮数
        for(int i=1;i<nums.length;i++){
            int temp=nums[i];//记录操作数
            int j=0;
            for(j=i-1;j>=0;j--){
                if(nums[j]>temp){
                    nums[j+1]=nums[j];

                }else
                    break;
            }
            if(nums[j+1]!=temp)
                nums[j+1]=temp;
        }

        for (int x:nums)
            System.out.println(x);
    }
};*/

二分（折半）查找算法


//二分（折半）查找算法
/*
前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，
若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找。找不到返回一个负数。


 */
package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args) {
        int[] nums = {10,20,50,65,88,90};//必须是有序的数列！！！
        int index=binarySearch(nums,90);
        System.out.println(index);
    }

    //二分查找算法
    public static int binarySearch(int[] nums,int key){
        int start=0;                //开始下标
        int end=nums.length-1;      //结束下标
        while (start<=end) {
            int middle=(start+end)/2;
            if(nums[middle]>key){
                end=middle-1;
            }else if(nums[middle]<key){
                start=middle+1;
            }else
                return middle;
        }return -1;
    }
};

Arrays工具类：


//Arrays工具类：用来操作数组（比如排序和搜索的各种方法）
package kk;
import java.util.Scanner;
import java.util.Arrays;
public class hello_world{
    public static void main(String[] args){
        int[] nums={45,65,76,87,98,901};

        //二分查找
        int index=Arrays.binarySearch(nums,98);
        System.out.println("找到的下标是："+index);

        //输出数组
        for (int n:nums){
            System.out.println(n);
        }
        //在测试输出数据时，可以使用，更加方便
        System.out.println(Arrays.toString(nums));


        //排序
        int[] nums2={10,32,11,44,543,22,12};
        Arrays.sort(nums2);         //快速排序
        System.out.println(Arrays.toString(nums2));


        //数组的复制
        int[] nums3=Arrays.copyOf(nums2,10);
        System.out.println(Arrays.toString(nums3));

        //判断两个数组的值是否相等
        System.out.println(Arrays.equals(nums2,nums3));

        //填充数组
        Arrays.fill(nums2,1);
        System.out.println(Arrays.toString(nums2));

    }

};