B站【狂神说Java笔记】-数组

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量670 收藏 1
点赞数 2
分类专栏： Java 文章标签： java 编程语言 数组
原文链接：https://www.bilibili.com/video/BV12J41137hu
版权

目录

狂神视频地址

https://www.bilibili.com/video/BV12J41137hu

1.数组的定义

  1. 数组是相同类型数据的有序集合。
  2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
  3. 其中，每一个数据称作一个数组元素，每一个数组元素通过一个下标来访问他们。
    3.1. 数组下标从0开始

2.数组声明和创建

  在类型后面加 [ ] 或者在数组名后面加 [ ]

dataType  数组名[]  = new dataType[数组长度]
dataType[]  数组名   = new dataType[数组长度]

在这里插入图片描述

int[] nums = new int[10];
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;

  获取数组长度

System.out.println("数组长度是："+nums.length);
数组长度是：10

3.Java内存分析

堆
  存储new 出来的对象和数组
  可以被所有的线程共享，不会存放别的对象引用

栈
  存放基本变量类型（会包括这个基本类型的具有数值）
  引用类型变量（会存放这个引用在堆里面的具体地址）

方法区
  可以被所有线程共享
  包含了所有的class和 static 变量

在这里插入图片描述

4.三种初始化

1.静态初始化 --创建+赋值

int[] a = {1,2,3};

2.动态初始化 – 包含默认初始化

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

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

5.数组的四个基本特点

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

ArrayIndexOutOfBoundsException：数组下标越界异常！

总结：

  1. 数组是相同数据类型的有序集合
  2. 数组也是对象。数组元素相当于对象的成员变量
  3. 数组长度是确定的，不可改变。

6.求数组最大值

public static void main(String[] args) {
    int[] nums = {1, 5, 2, 39, 2, 5, 72, 24};
    int max = nums[0];
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] > max){
            max = nums[i];
        }
    }
    System.out.println("数组的最大值是："+max);
}

7.打印数组

public static void main(String[] args) {
    int[] nums = {1, 5, 2, 39, 2, 5, 72, 24};
    for (int i : nums){
        System.out.print(i+" ");
    }
    System.out.println();
    System.out.println("===================");
    for (int i = 0;i<nums.length;i++){
        System.out.print(nums[i]+" ");
    }
}

8.反转数组

public static void main(String[] args) {
    int[] nums = {1, 5, 2, 39, 2, 5, 72, 24};
    for (int i = nums.length - 1; i >= 0; i--) {
        System.out.print(nums[i] + " ");
    }
}

9.多维数组

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

  二维数组

int[][] arr = new int[3][2]
定义了一个3行2列的数组

在这里插入图片描述

10.Arrays 类

  1. 数组的工具类java.utils.Arrays
  2. 由于数组对象本身没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作。
  3. Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名 进行调用。
  4. 具备以下常用功能
    4.1.给数组赋值：通过fill方法
    4.2.对数组排序：通过sort方法，按升序
    4.3.比较数组：通过equals方法比较数组中元素值是否相等
    4.4.查找数组元素：通过binarySearch 方法对排序好的数组进行二分查找法操作

Arrays.toString 实现

public static String toString(int[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

11.冒泡排序

  冒泡排序无疑是最出名的排序算法之一，总共有八大排序！
  冒泡排序、两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知！

在这里插入图片描述

public static void main(String[] args) {
    int[] arr = {1, 23, 6, 6, 2, 2, 23, 34, 5};
    //1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交互位置
    //2.每一次比较，都会产生一个最大，或者最小的数字
    //3.下一轮可以少一次排序
    //4.依次循环，直到结束！
    System.out.println(Arrays.toString(arr));
    sort(arr);
    System.out.println(Arrays.toString(arr));
}

public static void sort(int[] arr) {
    //外层循环，判断我们这个要走几次
    for (int i = 0; i < arr.length - 1; i++) {
        //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j+ 1];
                arr[j + 1] = temp;
            }
        }
    }
}

12.稀疏数组

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


  稀疏数组的处理方式是：
    记录数组一共有几行几列，有多少个不同值
    把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

![在这里插入图片描述](https://img-blog.csdnimg.cn/c205f62c3e3f4d39b276f71652f08deb.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDI1Nzk4,size_16,color_FFFFFF,t_70#pic_center)

在这里插入图片描述

控制台输出

原二维数组
======================
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
二维数组的有效值是：2
转换为稀疏数组
================================
11	11	2	
1	2	1	
2	3	2	
================
还原
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0

全部代码

package cn.bloghut.demo1;

import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.Stream;

/**
 * @author by 闲言
 * @classname P1
 * @description TODO
 * @date 2021/7/22 10:13
 */
public class P1 {
    public static void main(String[] args) {
        //创建一个11 * 11的二维数组，0为 默认 1为白子、2为黑子
        int[][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
        //打印二维数组
        System.out.println("原二维数组======================");
        print(arr);
        //获取维数组的有效值
        int sum = 0;
        for (int[] ints : arr) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    sum++;
                }
            }
        }
        System.out.println("二维数组的有效值是：" + sum);
        //构建稀疏数组
        int[][] arr2 = new int[sum + 1][3];
        arr2[0][0] = 11;
        arr2[0][1] = 11;
        arr2[0][2] = sum;
        int count = 0;
        //遍历二维数组，为稀疏数组赋值
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0) {
                    count++;
                    arr2[count][0] = i;
                    arr2[count][1] = j;
                    arr2[count][2] = arr[i][j];
                }
            }
        }
        System.out.println("转换为稀疏数组================================");
        print(arr2);
        //还原
        System.out.println("================");
        System.out.println("还原");

        int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
        }
        print(arr3);
    }

    /**
     * 打印二维数组
     *
     * @param arr
     */
    public static void print(int[][] arr) {
        String str = "[ ";
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
程序员闲言
关注
专栏目录
数组的基本概念和初始化方式
eclipse_yin的博客
05-01 8892
一．数组的基本概念 ·        数组可以看成是多个相同类型数据组合，对这些数据的统一管理。 ·        数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 ·        数组的元素可以是任何数据类型，包括基本类型和引用类型。 ·        C和C++中的数组都可以分配在栈上面，而JAVA中的数组是只能分配在堆上面的，因为JAVA中的数组是
数组
赫本的粉丝的博客
05-20 172
数组 数组的定义 package com.cheng.array; public class ArrayDemo01 { public static void main(String[] args) { int[] nums;//1.定义 nums = new int[12];//2.创建一个数组； //赋值 nums[0] = 1; nums[1] = 2; nums[2] = 3;
【笔记】Java基础——数组
Gu_jiaguaren的博客
07-29 161
数组 1.数组概述 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们 2.数组声明创建 首先必须声明数组变量，才能在程序中使用数组。声明语法： dataType[] arrayRefVar;//首选方法 或 dataType arryRefVar[];//效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVar=
java基础知识学习笔记六——数组
潇鹞枫语
06-29 191
数组（引用类型）数组是相同数据类型的有序集合1.    操作对象就是操作引用2.    数组也是对象，数组元素相当于对象的成员变量3.    数组的长度是确定的不可变得。越界：ArrayIndexOutOfBoundsExceptiona.length数组的长度。可以用增强for循环遍历数组数组声明 int[] a，或者 int a[]都可以。数组的创建a = new int[5];数组元素的初始...
有关方法返回一个很奇怪的问题 - 问题已解决（转载）
afa的专栏
02-24 1343
<br />http://www.blogjava.net/raylong1982/archive/2007/11/01/157542.html<br /> <br />早上看了java类库中java.util.Arrays 类的toString方法的源代码。如下：（这是JDK1.6的源代码）    public static String toString(long[] a) {<br />        if (a == null)<br />            return "null";<br
狂神笔记，b站狂神说课程笔记大全(最新)
09-19
b站狂神说课程笔记大全，每个部分都有 狂神说java系列笔记（java基础+javaweb+ssm+微服务）全套 狂神说上课笔记未删减 Java基础到技术升级 1、JavaSE：Java入门 2、JavaSE：基础语法 3、JavaSE：流程控制 4、JavaSE...
Java学习-狂神说-笔记-Java数组
qq_43104872的博客
03-03 199
Java数组 1. 数组概述 数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据，按照一定的先后持续排列组合而成。 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。 2. 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下
狂神说Java笔记资料
04-14
《狂神说Java笔记资料》是一份全面涵盖Java开发基础知识的文档集，旨在帮助学习者系统地掌握Java编程。这份笔记包含多个章节，每个章节都深入讲解了一个特定的主题，覆盖了从初学者到进阶开发者必备的知识点。 1. *...
java复习1之数组（进阶）
Stone 不会喝水的博客
03-11 199
二分查找 排序在前一篇文章中讲过了，所以二分查找也就有了基础，那么在代码中有middle = start + (end + start)/2;请问你还有哪些方法不？（提示：位运算？为啥不直接（start+end)/2呢？），请在评论区留下你的思考吧！ package 二分查找; public class test { public static void main(String[] args...
Arrays类学习
qq_34579060的博客
01-18 155
package com.song.source.java; import java.io.Serializable; import java.util.AbstractList; import java.util.Objects; import java.util.RandomAccess; public class Arrays { private Arrays() {} pri
Arrays工具类五个常用方法的使用的使用（对于数组而言）
woahxy的博客
02-17 548
1. boolean equals(int a[],int b[]) //判断两个数组是否相等 int arr1[]=new int[]{1,2,3,4}; int arr2[]=new int[]{1,3,2,4}; boolean isEquals=Arrays.equals(arr1,arr2); System.out.println(isEquals); //false 源码如下： public static boolean equals(int[] a,...
Arrays类 与 Arrays类中的常用方法及方法底层源码
qq_56501283的博客
06-16 365
目录1.Arrays类的概述2.Arrays类中的常用方法1.toString()2.equals()3.sort()4.binarySearch()Arrays类位于java.util 包中，该类包含用于操作数组的各种方法（如排序和搜索）。继承了Object类，也重写了许多Object类中的方法。 用前需导包：import java.util.Arrays。Arrays类中的toString() 返回指定数组的内容的字符串表示形式 执行结果： 如上图如果直接输出数组a，程序会默认调用Object类中的
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 323
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 391
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 702
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 690
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 551
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
狂神说JAVA系列全面学习笔记：基础到微服务架构
资源摘要信息:"狂神说java系列笔记涵盖了Java编程语言的核心知识点，从Java基础、Javaweb技术，到Spring框架、微服务架构以及容器化技术都有详细的记录。本系列笔记对理解Java语言的原理和应用实践具有重要的参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值