Java基础--函数和数组

最新推荐文章于 2022-06-22 15:49:39 发布
最新推荐文章于 2022-06-22 15:49:39 发布
阅读量423 收藏
点赞数
分类专栏： Java学习笔记 函数 文章标签： Java基础 数组 函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013136306/article/details/44751525
版权

第一讲 Java函数

一、函数的概述
1、函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) {
    执行语句;
    return 返回值;
}
public static int add(int a,int b){}
A：修饰符 。public static（静态的方法）
B：返回值类型 这个特定的功能完成后，需要返回一个结果。这个地方就是返回结果的类型。
C：函数名 为了方便使用这个函数，给它起个名字。这个名字要符合标识符命名规则。
D：参数类型 形式参数的数据类型
    **：形式参数 自定义的接收方
    **：实际参数 发出方add(3,5)
E：执行语句 那么这个语句是由多条语句组成。
F：return 这个功能执行完以后，需要有一个返回值，那么这个值有关键字return带回。

2、如何定义一个函数呢？

1>、既然函数是一个独立的功能，那么给功能的运算结果是什么先明确；
2>、在明确定义该功能的过程中是否需要未知的内容参与运算
 1. 明确函数返回值类型
 2. 明确函数的参数列表（参数的类型和参数的个数）

3、函数的使用及注意事项

A：一般函数只有被调用后，才执行。
B：void 表示没有返回。在这个函数的结尾可以不写return。其实jvm会自动的结尾处加上return;
C：函数中不能定义函数
D：如果定义自己的函数 两个明确
明确该功能的结果 其实就是该功能的返回类型。
明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数)参与运算。明确未知内容的类型和个数。

4、函数（方法）的重载

A:函数的重载（overload）：指一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者参数的个数不同，参数的类型不同；

 - 参数类型不同。int add(int i)void add(double d)
 - 参数个数不同。add(int a,int b);add(int a,int b,int c)
 - 参数顺序不同 print(String name, int age)   //参数顺序不同的重载是可以存在的,但是没有什么实际意义
B：特点：与返回值类型无关，只看参数列表。
C：好处：便于阅读，优化程序设计。

重载的实例：

/*
什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同。
那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

*/

class FunctionOverload 
{
    public static void main(String[] args) 
    {

//      add(4,5);
//      add(4,5,6);
        print99();

    }
    public static void print99(int num)
    {
        for(int x=1; x<=num; x++)
        {
            for(int y=1; y<=x; y++)
            {
                System.out.print(y+"*"+x+"="+y*x+"\t");
            }
            System.out.println();
        }
    }

    //打印99乘法表
    public static void print99()
    {
        print99(9);
    }

    //定义一个加法运算，获取两个整数的和。
    public static int add(int x,int y)
    {
        return x+y;
    }

    //定义一个加法，获取三个整数的和。
    public static int add(int x,int y,int z)
    {
        return add(x,y)+z;
    }
}


/*

void show(int a,char b,double c){}

a.
void show(int x,char y,double z){}//没有，因为和原函数一样。

b.
int show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。
c.

void show(int a,double c,char b){}//重载，因为参数类型不同。注意：重载和返回值类型没关系。

d.
boolean show(int c,char b){}//重载了，因为参数个数不同。

e.
void show(double c){}//重载了，因为参数个数不同。

f.
double show(int x,char y,double z){}//没有，这个函数不可以和给定函数同时存在与一个类中。


*/

5、写一个函数实现判断两个数中最大的一个数

package cn.itcast;

public class GetMax {

    /**
     * 写一个函数实现求取最大值
     * 
     * @author tsz
     *
     */
    public static void main(String[] args) {
        int max=getMax(10,5);
        System.out.println("最大的一个数："+max);

    }

    private static int getMax(int x,int y)
    {

        return x>y?x:y;
    }

}

6、定义方法实现十进制，二进制转换和十进制、十六进制转换

分析：首先熟悉进制的转换原理
这里写图片描述

class ToBin 
{
    public static void main(String[] args) 
    {
        //toBin(4);
        toHex(60);
        //System.out.println(Integer.toBinaryString(60));
    }
    //十进制转换为二进制，定义方法toBin（）
    public static void toBin(int num)
    {
        StringBuffer sb=new StringBuffer();
        while(num>0)
        {
            //System.out.println(num%2);
            sb.append(num%2);//把num%2的值通过sb存到append序列中
            num=num/2;
        }
        System.out.println(sb.reverse());
    }


    /*
        十进制转换为十六进制
    */
    public static void toHex(int num)
    {
        StringBuffer sb=new StringBuffer();
        for(int x=0;x<8;x++)
        {
            int temp=num & 15;
            if(temp>9)
                sb.append((char)(temp-10+'A'));//使用字符的UNcode编码
            else 
                sb.append(temp);

            num = num>>>4;
        }
        System.out.println(sb.reverse());
    }
}

在十进制转换十六进制时，原理如图所示：
这里写图片描述

第二讲 数组

一、一维数组的概述
数组:相同类型的数据按顺序组成的一种复合数据类型，通过数组名加下标来使用数组中的数据，下标从0开始排序；
1、一维数组的定义格式：

声明一维数组：数组元素类型[] 数组名
A：当不明确数组中的元素时,动态初始化
    举例 :
    int[] arr = new int[3];
    arr[0] = 3;
B：当明确数组中的元素时,静态初始化
    举例 :
    int[] arr = new int[]{1,2,3,4,5};
    int[] arr = {1,2,3,4,5};

2、什么时候使用数组？
当要操作的同种数据类型的数据是多个的时候，你就得想着先把这些数据用数组进行存储。
3、数组的内存图

A：栈
存储的是局部变量(在函数中定义的变量)。
变量被使用完后，立即自动释放。
B：堆
存储的是实体(数组和对象)。
实体：new出来的东西，可以存放很多数据的东西。
堆内存数据的特点
每个实体都有内存地址
堆内存中的变量都有默认初始化值
int --> 0
double --> 0.0
boolean --> false
char --> '\u0000' 空字符，unicode编码。
当实体不在被使用的时候，会在jvm空闲的时候，通过java垃圾回收机制使其自动释放。
C：方法区由static修饰
D：本地方法区 调用是Windows系统底层资源，我们不用考虑。
E：寄存器 和CPU相关。我们不用考虑。

4、数组获取最大最小值的实现

/*
给定一个数组{5,1,6,4,2,8,9}。

1，获取数组中的最大值，以及最小值。

*/

class ArrayTest 
{

    /*
    获取数组中的最大值。
    思路：
    1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
    通过一个变量进行临储。
    2，让数组中的每一个元素都和这个变量中的值进行比较。
    如果大于了变量中的值，就用该变量记录较大值。
    3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

    步骤：
    1，定义变量。初始化为数组中任意一个元素即可。
    2，通过循环语句对数组进行遍历。
    3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；

    需要定义一个功能来完成。以便提高复用性。
    1，明确结果，数组中的最大元素 int。、
    2，未知内容：一个数组。int[]
    */
    public static int getMax(int[] arr)
    {
        int max = arr[0];

        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>max)
                max = arr[x];
        }
        return max;
    }


    /*
    获取最大值的另一种方式。
    可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。


    */
    public static int getMax_2(int[] arr)
    {
        int max = 0;

        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }


    /*
    获取最小值。
    */
    public static int getMin(int[] arr)
    {
        int min = 0;
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]<arr[min])
                min = x;
        }
        return arr[min];
    }

    //获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。
    /*
    public static double getMax(double[] arr)
    {
        int max = 0;

        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }
    */
    public static void main(String[] args)
    {
        int[] arr ={5,1,6,4,2,8,9};

        int max = getMax_2(arr);
        int min = getMin(arr);
        System.out.println("max="+max);
        System.out.println("min="+min);


//      boolean[] ar = new boolean[3];
//      System.out.println(ar[1]);
    }

}

5、数组排序（选择排序和冒泡排序）

import java.util.*;
/*
对给定数组进行排序。
{5,1,6,4,2,8,9}


*/
class ArrayTest2 
{

    /*
    选择排序。
    内循环结束一次，最值出现头角标位置上。
    */
    public static void selectSort(int[] arr)
    {
        for (int x=0; x<arr.length-1 ; x++)
        {
            for(int y=x+1; y<arr.length; y++)
            {
                if(arr[x]>arr[y])
                {
                    /*
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y]= temp;
                    */
                    swap(arr,x,y);
                }
            }
        }
    }
    /*
    冒泡排序
    */

    public static void bubbleSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {                                   
            for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。
            {
                if(arr[y]<arr[y+1])
                {
                    /*
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                    */
                    swap(arr,y,y+1);//封装
                }
            }
        }
    }

    /*
    发现无论什么排序。都需要对满足条件的元素进行位置置换。
    所以可以把这部分相同的代码提取出来，单独封装成一个函数。
    */
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        //排序前；
        printArray(arr);

        //排序
        //selectSort(arr);
        //bubbleSort(arr);

        //Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
        //排序后：
        printArray(arr);

    }

    public static void printArray(int[] arr)
    {
        System.out.print("[");
        for(int x=0; x<arr.length; x++)
        {
            if(x!=arr.length-1)
                System.out.print(arr[x]+", ");
            else
                System.out.println(arr[x]+"]");

        }       
    }
}

6、数组查找（折半查找）
必须保证这个数组是有序的

class ArrayTest1 
{
    public static void main(String[] args) 
    {
        int []arr=new int[]{1,2,3,4,5,5,6,8};
        //int index=getIndex(arr,3);
        int index=halfSearch_2(arr,7);
        System.out.println("index----="+index);
    }

    //实现功能，获取Key第一次出现的位置
    public static int getIndex(int[] arr,int key)
    {
        for(int x=0;x<arr.length;x++)
        {
            if(arr[x]==key)
            {
                return x;
            }
        }
        return -1;
    }
    //使用折半查找法进行查找元素，定义函数
    public static int halfsearch(int[] arr,int key)
    {
        int min,max,mid;
        min=0;
        max=arr.length-1;
        mid=(max+min)/2;
        while(arr[mid]!=key)
        {
            if(key>arr[mid])
                min=mid+1;
            else if(key<arr[mid])
                max=mid-1;

            if(min>max){
                return -1;
            }
            mid=(max+min)/2;
        }
        return mid;
    }
    //第二种折半的方式
    public static int halfSearch_2(int[] arr,int key)
    {
        int min=0,max=arr.length-1,mid;
        while(min<=max)
        {
            mid=(max+min)>>1;//这就相当于除以2
            if(key>arr[mid])
                min=mid+1;
            else if(key<arr[mid])
                max=mid-1;
            else
                return mid;
        }
        return -1;
    }


}

7、使用查表法实现进制的转换

class ArrayTest6 
{
    public static void main(String[] args) 
    {
//      toHex(60);
        toBin(-6);
    }

    public static void toBin(int num)
    {
        //定义二进制的表。
        char[] chs = {'0','1'};

        //定义一个临时存储容器。
        char[] arr = new char[32];

        //定义一个操作数组的指针
        int pos = arr.length;

        while(num!=0)
        {
            int temp = num & 1;

            arr[--pos] = chs[temp];

            num = num >>> 1;
        }

        for(int x=pos; x<arr.length; x++)
        {
            System.out.print(arr[x]);
        }
    }


    /*
        0 1 2 3 4 5 6 7 8 9 A  B  C   D  E  F  ==十六进制中的元素。
        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

        查表法：将所有的元素临时存储起来。建立对应关系。
        每一次&15后的值作为索引去查建立好的表。就可以找对应的元素。
        这样比 -10+'a'简单的多。

        这个表怎么建立呢？
        可以通过数据的形式来定义。

        发现终于出结果了。但是是反着的。想要正过来呢？可以通过StringBuffer reverse功能来完成。
        但是这个工具还没有学习。

        所以可以使用已经学习过的容器：数组来完成存储。；

    */

    public static void toHex(int num)
    {
        char[] chs = {'0','1','2','3'
                    ,'4','5','6','7'
                    ,'8','9','A','B'
                    ,'C','D','E','F'};

        //定义一个临时容器。
        char[] arr = new char[8];
        int pos = arr.length;

        while(num!=0)
        {
            int temp = num & 15;

            //System.out.println(chs[temp]);
            arr[--pos] = chs[temp];


            num = num >>> 4;
        }
        System.out.println("pos="+pos);
        //存储数据的arr数组遍历。
        for(int x=pos;x<arr.length; x++)
        {
            System.out.print(arr[x]+",");
        }

    }
}

二维数组
1、二维数组的格式：

格式1:int[][] arr = new int[3][2];
A：定义了名称为arr的二维数组
B：二维数组中有3个一维数组
C：每一个一维数组中有2个元素
D：一维数组的名称分别为arr[0], arr[1], arr[2]
arr:二维数组名
arr[1]:二维数组中的第二个一维数组名
arr[1][1]:二维数组中的第二个数组的第二个元素
E：给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式2：int[][] arr = new int[3][];
A: 二维数组中有3个一维数组
B: 每个一维数组都是默认初始化值null
C: 可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[5];
arr[2] = new int[7];
格式3:int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
A：二维数组有3个一维数组。
B：
第一个一维数组有3个元素
第二个一维数组有2个元素
第三个一维数组有4个元素

2、二维数组的遍历

class Array2Demo 
{
    public static void main(String[] args) 
    {
//      int[] arr = new int[3];//一维数组。

        //int[][] arr = new int[3][4];//定义了名称为arr的二维数组。二维数组中有3个一维数组。
                                    //每一个一维数组中有四个元素。

        //System.out.println(arr[0][1]);

        /*
        int[][] arr  = new int[3][];

        arr[0] = new int[3];
        arr[1] = new int[1];
        arr[2] = new int[2];


        System.out.println(arr.length);//打印是二维数组的长度 3；
        System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
        */

        int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};

        int sum = 0;
        for(int x=0; x<arr.length;x++)
        {
            for(int y=0; y<arr[x].length; y++)
            {
                sum = sum + arr[x][y];
            }
        }

        System.out.println("sum="+sum);
    }
}
唐枫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java语言基础(二)——函数与数组
李阿昀的博客
12-01 1377
Java语言基础函数函数的定义 函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。 函数的格式：修饰符 返回值类型 函数名(参数类型 形式参数1, 参数类型 形式参数2, ... ) { 执行语句; return 返回值; } 返回值类型：函数运行后的结果的数据类型。 参数类型：是形式参数的数据类型。 形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
Java day04（数组与函数）
qq_40871485的博客
11-19 224
数组和函数 在执行程序的时候，经常要存储大量的数据，如果我们要读入100个数，并对其进行一系列操作，必须声明100个变量，这样会出现很多的变量的声明，为了解决这种问题，Java中提供了一种数组的数据结构。（array） 数组常见的有一维的和二维的，数组一旦被创建，它的大小是固定的。使用一个数组引用变量，通过下标来访问数组中的元素。 数组是用来存储数据的集合，数组其实是一个存储具有相同数据类型...
黑马程序员.bobo.DAY.4
u010489586的专栏
07-15 633
Day-4 1.数组(静态初始化,常见问题) 2.数组(常见操作-遍历)     3.数组(常见操作-获取最值) /* 给定一个数组{5,1,6,4,2,8,9}. 1,获取数组中的最大值,以及最小值. */ class ArrayTest { /* 获取数组中的最大值 思路: 1,获取最值需要进行比较.每一次比较都会有一个较大的值,因为该值不确定
Java编程定义一个数组，输出数组中的最大值与最小值
Chlin.Rei的博客
06-22 4842
Java编程定义一个数组，输出数组中的最大值与最小值
Java---数组练习-获取最值，选择、冒泡排序
小码农1024的博客
05-22 412
1、获取数组中的最大值、最小值 /* 给定一个数组{5,1,6,4,2,8,9} 1、获取数组中的最大值，及最小值 */ public class ArrayTest { public static void main(String[] args) { //int类型数组 int arr[] = {5,1,6,4,2,8,9}; int max = getMax(arr); ...
黑马程序员——java基础--java语言入门
huang1165441461的博客
05-19 837
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
Java数组的最值
街角
05-15 1172
Java数组的最值 开发工具与关键技术：myEclipse javaEE 作者：街角 撰写时间：20180515 给定一个数组{5,1,6,4,2,8,9}。 获取数组中的最大值，以及最小值。 1. 2. class ArrayTest 3. { 4. /* 5. 获取数组中的最大值。 6. 思路： 7. 1，获取最值需要进行比较。每一次...
java实例-数组（学习资料）
06-17
在实际开发中，数组常用于存储和处理大量有序或无序的数据，而Java提供的`Arrays`类提供了许多便利的方法，简化了对数组的操作，提高了代码的效率和可读性。熟练掌握数组及其相关操作对于理解和编写高效的Java代码至...
Java中数组实例---一维数组.pdf
07-11
在Java编程语言中，数组是一种特殊的数据结构，用于存储...通过这个实例，我们可以深入理解Java中一维数组的创建、初始化和遍历的基本概念，这对于后续学习更复杂的数组操作，如多维数组和数组操作函数，奠定了基础。
ArrayListJavaImplementation:重新实现的存储库和类数组列表的Java数组-SENAI Blumenau-3ºSemestre
03-27
- 构造函数：初始化数组的大小，可能还包括默认容量的设置。 - add()方法：添加元素到ArrayList，包括在末尾添加和在指定位置插入。 - remove()方法：删除元素，要考虑是否需要移动后续元素来填补空位。 - get()和...
java代码-数组 40 李启强
07-15
在Java编程语言中，数组...以上40个知识点涵盖了Java数组的基础到进阶的使用，通过深入学习和实践，能够有效地提升Java编程能力。在阅读提供的`main.java`和`README.txt`文件后，你可以进一步了解具体示例和应用场景。
Java 实例 - 数组排序及元素查找源代码-详细教程.zip
08-07
在Java编程语言中，数组是基础且重要的数据结构，用于存储一组同类型的元素。本教程主要涵盖两个核心主题：数组的排序和元素查找。通过学习这些概念，开发者能够有效地管理和操作数组，提升程序的效率。 一、数组...
给定一个数组，获取数组中的最大值，以及最小值。
weixin_30572613的博客
03-05 416
package question; public class ArrayTest { /**给定一个数组{5,1,6,4,2,8,9}获取数组中的最大值，以及最小值。 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ...
今日头条编程题——给定一个数组序列，需要求选出一个区间，使得该区间是所有区间中“区间中的最小数 * 区间所有数的和”的值最大的一个
薰衣草PK向日葵的博客
07-06 3851
题目描述 给定一个数组序列，需要求选出一个区间，使得该区间是所有区间中经过如下计算的值最大的一个： 区间中的最小数 * 区间所有数的和 最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列[6 2 1]则根据上述公式，可得到所有可以选定各个区间的计算值： [6] = 6 * 6 = 36; [2] = 2 * 2 = 4; [1] = 1 * 1 = 1; [6,2] = 2 * 8 = 16; [2,1] = 1 * 3 = 3; [6, 2, 1] = 1 * 9 =.
基于JavaWeb开发的图书管理系统 (源码+数据库).zip-大作业&课程设计
09-07
基于JavaWeb开发的图书管理系统 (源码+数据库).zip-大作业&课程设计，本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的话可以放心下载使用。 基于JavaWeb开发的图书管理系统 (源码+数据库).zip-大作业&课程设计，本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的话可以放心下载使用。 基于JavaWeb开发的图书管理系统 (源码+数据库).zip-大作业&课程设计，本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的话可以放心下载使用。 基于JavaWeb开发的图书管理系统 (源码+数据库).zip-大作业&课程设计，本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求如果。
武汉工程大学邮电与信息工程学院在广东2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
青岛工学院在广东2021-2024各专业最低录取分数及位次表.pdf
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
android studio 配套资源 gradle8.9all
09-07
android studio 配套资源 gradle8.9all
自动升降收料设备_机械3D图Solidworks设计图.zip
09-07
自动升降收料设备_机械3D图Solidworks设计图
Java基础：方法与数组详解
"Java基础知识，包括方法（函数）的定义、特点、应用和重载，以及数组的使用和内存分配的解析。" 在Java编程语言中，方法（函数）是组织代码的重要方式，它们允许我们将复杂的任务分解为一系列可重用的步骤。方法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值