Java编程之路——学习笔记（六）

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量123 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dontask_dontknow/article/details/118541203
版权

总目录

数组详解

数组可以看成是矩阵，用来存储数据的（多维）列表，是一种数据结构

数组概述

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

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

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

数组声明创建

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

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

  • 声明数组变量之后，使用new操作符来创建数组，语法如下：

    dataType[] arrayRefVar = new dataType[arraySize];

  • 数组的元素是通过索引访问的，数组索引从0开始。访问语法为arrayRefVar[0]

  • 获取数组长度的语法为：arrayRefVar.length

《创建数组》代码实例：

package Szx.array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        //变量类型 变量名称 = 变量值;
        //1.声明数组变量
        int[] numbers;
        //int numbers[];	
        //2.创建一个可以存储10个元素的数组
        numbers = new int[10];
        
        /*合并声明与创建数组语句
        *int[] numbers = new int[10];
        */
        
        //3.给数组元素赋值
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        numbers[5] = 6;
        numbers[6] = 7;
        numbers[7] = 8;
        numbers[8] = 9;
        //没有赋值的元素默认为0
        System.out.println(numbers[9]);
        
        //计算数组元素数值总和
        int sum = 0;
        for (int i=0; i<numbers.length; i++) {
            sum += numbers[i];
        }
        System.out.println("总和为："+sum);
    }
}

Java内存分析：

  • 堆
    • 存放new对象和数组
    • 可以被所有的线程共享，不会存放别的对象引用
  • 栈
    • 存放基本变量类型（会包含这个基本类型的具体数值）
    • 引用对象的变量（会存放这个引用在堆里面的具体地址）
  • 方法区
    • 可以被所有的线程共享
    • 包含了所有的class和static变量

画图便于理解概念
在这里插入图片描述

三种初始化：

  • 静态初始化*（固定值不能变动）*

    int[] arrayVar = {1,2,3};
Man[] mans = {new Man(1,1), new Man(2,2)};//引用Man类（自建）

  • 动态初始化（变量值可以变动）

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

  • 数组的默认初始化

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

《初始化》代码实例：

package Szx.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8,9,10};
        System.out.println(a[0]);
        //动态初始化：声明 + 创建
        int[] b= new int[10];
        b[0] = 11;
        //动态初始化包含【默认初始化】
        System.out.println(b[1]);
    }
}
//java.lang.ArrayIndexOutOfBoundsException错误：显示数组下标超出额定范围

数组的四个基本特点：

  1. 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
  2. 其元素必须是相同类型，不允许出现混合类型
  3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  4. 数组变量属引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组边界：

  • 下标的合法区间：[0, length-1]，如果越界就会报错；

    public static void main(String[] args) {
    int[] a = new int[10];
    //打印数组的第十个元素
    System.out.println(a[9]);
}

  • ArrayIndexOutOfBoundsException：数组下标越界异常！

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

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

  • 数组长度是确定的，不可变的。如果越界，则会报出ArrayIndexOutOfBoundsException的错误

数组的使用

数组的使用无非有四种：

  1. 普通的For循环（对数组元素进行操作，例如打印计算等）
  2. 增强For循环，For-Each循环（打印数组元素）
  3. 数组作为方法入参
  4. 数组作返回值

《数组使用》代码实例：

package Szx.array;

public class ArrayDemo03  {
    public static void main(String[] args) {
        //静态初始化数组元素
        int[] arrays = {1,2,3,4,5};
        //普通for循环——打印全部数组元素
        System.out.println("打印数组中所有的元素：");
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(+arrays[i]+" ");
        }
        System.out.println();
        System.out.println("=============");
        //计算数组中所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("数组元素总和为："+sum);
        System.out.println("=============");
        //查找数组元素中的最大值
        int max = 0;
        for (int i = 0; i < arrays.length; i++) {
            if (max<arrays[i]) {
                max = arrays[i];
            }
        }
        System.out.println("数组元素中最大值为："+max);
        System.out.println("=============");
        //增强for循环，打印数组元素，没有运用到下标
        //简化写法：arrays.for 数组名称+.for
        for (int i : arrays) {
            System.out.println(i);
        }
        System.out.println("=============");
        //引用数组方法
        printArray(arrays);
        System.out.println("=============");
        //引用反转数组方法
        int[]  reverse = reverse(arrays);
        printArray(reverse);
    }


    //数组作为方法入参——打印数组元素的方法
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println("数组中第"+(i+1)+"个值为："+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;
    }
}

多维数组

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

  • 声明并创建二维数组的语法格式为：

    int array[][] = new int[2][3];

    以上二维数组array可以看成一个两行三列的数组

  • 画图分析便于理解概念：
    在这里插入图片描述

《多维数组》代码实例：

package Szx.array;

public class ArrayDemo04 {
    public static void main(String() args) {
        //4行2列数组
        int[][] array = {{1,2}, {2,3}, {3,4}, {4,5}};
        //提取数组元素-第一行第一列
        System.out.println(array[0][0]);
        System.out.println(array[0][1])
        //遍历打印出二维数组元素
        for (int i=0; i<array.length; i++) {
            for (int j=0; j<array[i].length) {
                System.out.println(array[i][j]);
            }
        }
    }
}

Arrays类

  • 数组的工具类java.util.Arrays
  • 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
  • 查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是 “不用” 而不是 “不能” ）
  • 具有以下常用功能：
    • 给数组赋值：通过fill方法
    • 对数组进行排序：通过sort方法，按升序
    • 比较数组：通过equals方法比较数组中元素值是否相等
    • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

《Arrays工具类》代码实例：

package Szx.array;

import java.util.Arrays;

public class ArrayDemo05 {
    public static void main(String[] args) {
        //静态初始化数组
        int[] a = {1,23,4,7,10,2,531};
        //直接打印 - [I@1b6d3586
        System.out.println(a);
        //打印数组元素Arrays类方法
        System.out.println(Arrays.toString(a));
        //打印数组元素自创方法
        printArray(a);

    }

    //不依赖工具类的方法，自己写的方法
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            if (i==0) {
                System.out.print("[");
            }
            if (i==arrays.length-1) {
                System.out.print(arrays[i] + "]");
            }else {
                System.out.print(arrays[i] + ", ");
            }
        }
    }
}

《sort数组排序与fill数组填充》代码实例：

package Szx.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        //静态初始化数组
        int[] a = {1,23,4,7,10,2,531};
        //使用Arrays工具类对数组进行升序排序
        Arrays.sort(a);
        //输出排序结果
        System.out.println(Arrays.toString(a));

        //填充数组——下标2到4填充数值0
        Arrays.fill(a, 2,  4, 0);//Arrays.fill(a, fromIndex:2, toIndex:4, val:0)
        //输出填充结果
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序
  • 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较
  • 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)

《冒泡排序及优化》代码实例：

package Szx.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {5,6,9,23,14,2,4,1,0};
        int[] sort_over = sort(a);
        System.out.println(Arrays.toString(sort_over));
    }

    //冒泡排序算法
    //1.在比较数组中，两个相邻的元素进行比较，如果第一个数比第二个数大，就互换位置
    //2.每一次比较，都会产出一个最大值与最小值，要通过临时变量来存储最小值/最大值，已完成互换位置的操作
    //3.冒泡排序的好处是：下一轮则可以少一次排序
    //4.依次排序，直到结束
    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;

        //外层循环：判断数组要走多少次循环
        for (int i=0; i<array.length-1; i++) {
            //通过flag标识位减少没有意义的比较
            boolean flag = false;
            //内层循环：比较判断两个元素，如果第一个数大于第二个数，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]) { //降序算法：array[j+1]>array[j];
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            //优化算法
            if (flag==false) {
                break;
            }
        }
        return array;
    }
}

稀疏数组(数据结构)

  • 需求：编写五子棋游戏中，有存盘退出和续上盘的功能
    在这里插入图片描述

  • 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据

  • 如何解决：稀疏数组

稀疏数组介绍

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

  • 稀疏数组的处理方式是：

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

  • 如下图：左边是原始数组，右边是稀疏数组
    在这里插入图片描述

  • 稀疏数组的第一列记录着，原始数组共有6行7列，有8个不同的数值。[1]第一个数值为22，在数组的第0行第3列；…；[8]第八个数值为28，在数组的第5行第2列

《创建稀疏数组》代码实例：

package Szx.array;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0：表示没有棋子；1：黑棋；2：白棋
        int[][] array1 =  new int[11][11];
        //部署黑棋和白棋的位置信息 黑棋第2行第3列 白棋第3行第4列
        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("=============");
        //转换为稀疏数组保存
        //1.获取有效值的个数——在此例中，即1和2两个元素
        int virtual = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0) {
                    virtual++;
                }
            }
        }
        System.out.println("有效值的个数为："+virtual);
        System.out.println("=============");
        //2.创建稀疏数组，为[有效值]行3列
        int[][] array2 = new int[virtual+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = virtual;
        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];
                }
            }
        }
        //3.输出稀疏数组
        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("=============");
        //4.还原稀疏数组
        System.out.println("输出还原的数组");
        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //给其中的元素还原它的值
        for (int i = 1; i < array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();//换行
        }

    }
}
dontask_dontknow
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python学习笔记（六）——–Python函数
12-22
Python函数类似Java中的方法。 二、定义一个Python函数 Python中以def开始定义函数，无需注明函数的返回值类型。 函数名后跟()，其中放入函数所需要的参数，同样的参数不需要注明类型。 函数体以冒号开始，并且...
Collection学习笔记——每天一个Java小技巧
12-21
在Java编程语言中，`Collection` 是一个非常重要的接口，它是所有单列集合（单一元素存储）的顶级接口。在本文中，我们将深入探讨 `Collection` 接口及其相关概念，包括常用方法、遍历机制（迭代器）以及一些实用...
NumPy进阶修炼｜热身20题
早起Python
04-28 944
我的公众号：早起Python 关注第一时间接收最新文章 === 大家好，NumPy系列讲解已经更新了两期，今天将整理一些相关的题目来实际操作一下，因为在Pandas系列中有涉及到部分NumPy操作因此我也不确定最终会有多少题，暂且先来个20题热热身吧！ 01数据查看 题目：导入并查看NumPy版本 难度：⭐ 答案 import numpy as np print(np.__ver...
Numpy基础
wh22141334的博客
05-04 5484
import numpy as np print(np.__version__) all_zeros=np.zeros(10) all_zeros=np.zeros(10,dtype='int') value=np.arange(0,5,100) List=[1,2,3,4,5,6,7,8,9] list2arr=np.array(List)
NumPy进阶80题完整版｜附Notebook版本下载
早起Python
07-22 1058
前言 大家好，NumPy进阶修改80题现在已经全部更新完毕，80道习题涵盖了NumPy中数组创建、访问、筛选、修改、计算等常用操作，如果不熟悉NumPy的读者可以刷一遍，因为里面的代码大多拿走就能用，所以如果你已经了解NumPy的基本操作，我更建议将这80题当成速查手册使用，随用随查！本文共分为两个部分： 完整版NumPy80题 Notebook版下载方式 完整版80题 1.导入并查看NumPy版本 import numpy as np print(np.__version__) 1.15.4 2.
numpy找到矩阵中不同元素的种类_NumPy进阶80题完整版｜附Notebook版本下载
weixin_39968852的博客
11-27 459
前言大家好，NumPy进阶修改80题现在已经全部更新完毕，80道习题涵盖了NumPy中数组创建、访问、筛选、修改、计算等常用操作，如果不熟悉NumPy的读者可以刷一遍，因为里面的代码大多拿走就能用，所以如果你已经了解NumPy的基本操作，我更建议将这80题当成速查手册使用，随用随查！本文共分为两个部分：完整版NumPy80题Notebook版下载方式完整版80题1.导入并查看NumPy版本impo...
python numpy 奇数偶数行互换_NumPy进阶修炼｜热身20题
weixin_39828457的博客
11-27 538
我的公众号：早起Python关注第一时间接收最新文章===系列导读NumPy进阶修炼｜入门​mp.weixin.qq.comNumPy进阶修炼｜基础​mp.weixin.qq.com大家好，NumPy系列讲解已经更新了两期，今天将整理一些相关的题目来实际操作一下，因为在Pandas系列中有涉及到部分NumPy操作因此我也不确定最终会有多少题，暂且先来个20题热热身吧！01数据查看题目：导入并查看N...
Java学习笔记 —— 链式编程学习笔记
Marinda_Speed的博客
12-16 1397
链式编程大家可能有些熟悉也有些许陌生，我们今天来揭开这个神秘面纱。每次方法调用后都返回当前对象，非常不可思议吧，没想到还可以那么玩！我们今天来学习一下使用Lombok和原生的代码来实现链式编程。
「我的编程笔记」——记录学习中的代码、函数、概念等
热门推荐
想你依然心痛的博客
08-22 4万+
常用代码、特定函数、复杂概念、特定功能……在学习编程的过程中你会记录下哪些内容？快来分享你的笔记，一起切磋进步吧！编程如同探索一条未知的道路，需要不断地积累、总结和分享经验，才能更加深刻地理解和掌握其中的技巧和知识点。因此，分享一下自己在编程学习过程中记录的笔记，让我们一起分享、学习、进步，共同探索编程技巧与知识点。之前在这篇博客里面也提到过一些，还没看过可以移步过去看看。
Java学习笔记——网络原理1
qq_38592678的博客
05-21 1962
TCP是有连接的，而UDP是无连接的。​ TCP要想通信需要先建立连接，且需保存对方信息。​ UDP可以直接发送数据，不用保存对方信息(但是写程序的人需要保存，调用UDP api的时候要将对方的信息发送过去)。TCP是可靠传输，而UDP是不可靠传输。​ TCP传输数据有一系列保障数据的传输，如超时重传，应答机制，流量控制，序列号机制，拥塞控制，数据校验。​ UDP的不可靠传输体现在，其发送完数据后不保证数据能够到达目标地址。​ 可靠传输也是有代价的——机制更复杂，传输效率更低。
【Java】函数式编程学习笔记——Optional
See_Star的博客
04-09 2971
函数式编程——Optional
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JAVA学习笔记————————
04-25
通过阅读和学习这些JAVA学习笔记，开发者不仅可以掌握JAVA编程的基本技能，还能深入了解其设计理念，从而更好地应对各种实际开发问题。不断更新和完善自己的JAVA知识体系，对于成为一名优秀的JAVA开发者至关重要。
个人学习的java笔记——思维导图
01-25
这份"个人学习的java笔记——思维导图"涵盖了上述诸多Java编程的核心知识点，通过思维导图的方式，使得学习者可以更直观地理解和记忆这些复杂的概念，对提升Java学习效果大有裨益。无论你是初学者还是有经验的开发者...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 591
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
Karen198的博客
07-31 506
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 548
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
JavaSE面向对象进阶
qq_45348840的博客
07-30 469
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 348
1.导入hutool的maven依赖。2.直接复制一下代码运行。
面向对象编程基础——Java学习笔记
总结来说，Java学习笔记深入浅出地介绍了面向对象编程的概念，包括对象、类、属性、方法、高内聚、低耦合以及代码复用，这些都是Java编程的基础，也是理解面向对象编程的关键。对于Java初学者来说，这份笔记提供了很...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值