Java学习笔记（四）

最新推荐文章于 2024-06-17 18:07:51 发布

Jackson96

最新推荐文章于 2024-06-17 18:07:51 发布

阅读量285

点赞数 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();
        }

    }
}

Jackson96

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java学习笔记（四）

2020.09.13 Java学习笔记（四）一.Java方法详解1.System.out.println();是什么？类：system out：输出对象 println()：方法即调用系统类里的标准输出对象out中的方法 println()2.Java方法是语句的集合，他们在一起执行一个功能。方法是解决一类问题的步骤的有序组合方法包含于类或者对象中方法在程序中被创建，在其他地方被引用3.设计方法的原则：方法的本意是功能块，就是实现某个功能语句块的集合。在设计方法的时候
复制链接

扫一扫