Java学习笔记（四）

最新推荐文章于 2023-01-09 13:20:20 发布

Jackson96

最新推荐文章于 2023-01-09 13:20:20 发布

阅读量311

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Jackson96/article/details/108564055

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java学习笔记（四）

一.Java方法详解

1.System.out.println();是什么？

类：system out：输出对象 println()：方法

即调用系统类里的标准输出对象out中的方法 println()

2.Java方法是语句的集合，他们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合

方法包含于类或者对象中

方法在程序中被创建，在其他地方被引用

3.设计方法的原则：

方法的本意是功能块，就是实现某个功能语句块的集合。在设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，有利于后期扩展。

代码：

public class Demo0 {
    //main方法
    public static void main(String[] args) {
        int sum=add(1,2);
        System.out.println(sum);
        System.out.println("================");
        test();
    }
    //加法
    public static int add(int a,int b){
        return a+b;
    }
    public static void test(){
        for (int i = 0; i <= 1000; i++) {
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){
                System.out.println();
            }
        }
    }
}

格式：

修饰符返回值类型方法名（参数类型参数名）{

…

方法体

…

return 返回值；

}

4.方法调用

调用方法：对象名.方法名（实参列表）

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当作一个值。例如：

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println();

java都是值传递

5.方法重载

（1）重载就是在一个类中，有相同的函数名称，但是形参不同的函数。

（2）方法重载的规则

a.方法名称必须相同

b.参数列表必须不同（个数不同，或者类型不同，参数排列顺序不同等）

c.方法的返回类型可以相同也可以不同

d.仅仅返回类型不同不足以成为方法的重载

（3）实现理论：

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

6.可变参数

在方法声明中，在指定参数类型后加一个省略号（…）

一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

代码：

public class DFemo03 {
    public static void main(String[] args) {
      DFemo03 Demo03 =  new DFemo03();
      Demo03.test(1,2,3,4,5,6,7);

    }
    public void test(int...i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }
}

7.递归

递归就是A方法调用A方法！就是自己调用自己。

递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

递归头：什么时候不调用自身方法。如果没有头，将会陷入死循环

递归体：什么时候需要调用自身方法

代码：

public class Demo04 {
    //2!    2*1
    //5!    5*4*3*2*1
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    //1!
    //2 2*f(1)
    //3 3*f(2)
    public static int f(int n){
        if(n==1){
            return 1;
        }
        else{
            return n*f(n-1);
        }
    }
}

二.数组

1.数组的定义

数组是相同类型数据的有序集合。

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。

其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

2.数组声明创建

首先必须声明数组变量，才能在程序中使用数组。声明数组语法：

dataType[] arrayRefVar; //首选方法

dataType arrayRefVar[]; //效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始。

获取数组长度：array.length

3.java内存分析

在这里插入图片描述

4.数组三种初始化

静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)}

动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

数组的默认初始化

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

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W2iKO3oJ-1599985685464)(C:\Users\Jackson\AppData\Roaming\Typora\typora-user-images\image-20200911095121750.png)]$

5.数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可改变的。

其元素必须是相同类型，不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象实在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

6.数组边界

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

public static void main(String[] args){
    int[] a=new int[2];
    System.out.println(a[2]);
}

小结：

数组是相同数据类型（数据类型可以为任意类型）的有序集合。

数组也是对象。数组元素相当于对象的成员变量。

数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds

7.数组使用

代码：

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        //无下标
        for (int array : arrays) {
            System.out.println(array);
        }
        //printArray(arrays);
        int[] reverse=reverse(arrays);
        printArray(reverse);
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转操作
        for(int i=0,j=result.length-1;i<arrays.length;i++,j--){
                result[j]=arrays[i];
        }
        return result;
    }
}

8.多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组定义：

int a[][] = new int[2][5]

代码：

public class Demo05 {
    public static void main(String[] args) {
        //[3][2]
        /*
        1,2 array[0]
        2,3 array[1]
        3,4 array[2]
         */
        int[][] array = {{1,2},{2,3},{3,4}};
        //printArray(array[0]);
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

9.Arrays类

数组工具类java.util.Arrays

代码：

import java.util.Arrays;
public class Demo06 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,9000,32123,651,21,2,23};//[I@4554617c
        System.out.println(a);
        //打印数组元素
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//数组排序，升序
        System.out.println(Arrays.toString(a));
    }
}

10.冒泡排序

冒泡排序一共两层，外层冒泡轮数，里层依次比较。时间复杂度为O(n2)

代码：

import java.util.Arrays;
public class Demo07 {
    public static void main(String[] args) {
            int[] a = {9,5,7,8,6,3,0,2,1,4};
            int[] sort = sort(a);//调用冒泡排序
        System.out.println(Arrays.toString(sort));
    }
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每次比较都会产生出一个最大，或者最小的数字
    //3.下一轮则可以少一次排序
    //4.一次循环，直到结束！
    public static int[] sort(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个要走多少次
        for(int i=0;i<array.length-1;i++){
            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            boolean flag = false;//通过flag标识位减少没有意义的比较
            for(int j=0;j<array.length-1-i;j++){
                if(array[j+1] > array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

11.稀疏数组

当一个数组中大部分元素是0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式：

记录数组一共有几行几列，有多少个不同值。

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3sqsIDia-1599985685465)(C:\Users\Jackson\AppData\Roaming\Typora\typora-user-images\image-20200913104433087.png)]$

代码：

public class Demo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11  0：没有棋子，1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组:");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("=============================");
        //转换为稀疏数组保存
        //获取有效值个数
        int sum=0 ;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，将非0的值，存放在稀疏数组中
        int count=0;
        for(int i=0;i<array1.length;i++){
            for(int j=0;j<array1[i].length;j++){
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];

                }

            }
        }

        //输出稀疏数组
        System.out.println("输出稀疏数组:");
        for(int i=0;i< array2.length;i++){
            System.out.println(array2[i][0]+"\t"
                              +array2[i][1]+"\t"
                              +array2[i][2]+"\t");
        }
        System.out.println("=============================");

        System.out.println("稀疏数组还原:");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原他的值
        for(int i=1;i<array2.length;i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印输出
        //输出原始数组
        System.out.println("输出还原数组:");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}