Java的数组——小白篇(9)

最新推荐文章于 2024-10-30 10:20:22 发布
最新推荐文章于 2024-10-30 10:20:22 发布
阅读量184 收藏
点赞数 1
分类专栏： Java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48101294/article/details/110429588
版权

一. 数组的定义

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
  • 其中每个数据称为一个数组元素每个数组元素可以通过一个下标来访问它们。

二. 数组声明和创建

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

int[] max;//首选的方法
int max[];//两个效果一样，但不是首选方法

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

int [] max = new int [ 数组长度];
  • 数组的元素是通过索引访问的，数组索引从0开始。
  • 获取数组长度：数组变量名.length
  • 案例理解

三. 数组的三种初始化

  • 静态初始化
  int[] a= {1,2,3};
  Man[] mans = {new Man(1,1),new Man(2,2)};
  • 动态初始化
  int[] a= new int[];
  a[0]=1;
  a[1]=2
  • 数组的默认初始化
    数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

四. 数组的四个基本特点

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

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

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

  • 数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。

  • 数组本身就是对象，Java中队象是推中的，因此数组无论保存原始类型还是其他类型，数组队象本身是在推中的.

    数组边界

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

   public static void main(String[] args){
   int []a=new int[2];//定义第一个数组为2
   System.oiut.println(a[2]);//而输出第三个数组，所以会报错。
   }
  • ArraylndexOutOfBoundsExcption:数组下标越界异常.

小结：

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

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

  • 数组长度的确定的，不可变的。如果越界，则报ArraylndexOutOfBoundsExcption

  • 理解：下方代码为什么报错

  public static void main(String[] args){
  int[] a={1,2,3,4,5,6,7,8};
      System.out.println(a[0]);
      for (int i=0;i<=a.length;i++){
          System.out.println(a[i]);
      }
  }

五. 数组的使用

  1. 普通的for循环

  2. for- Each 循环

  3. 数组作方法入参

  4. 数组作返回值

1. 普通的for循环

案例：打印全部的数组元素

 public static void main(String[] args){
  int[] a={1,2,3,4,5,6,7,8};
      for (int i=0;i<a.length;i++){//将a数组的数全部循环出来
          System.out.println([i]);
      }   
  }

案例：计算所有元素的和

 public static void main(String[] args){
  int[] a={1,2,3,4,5,6,7,8};
      int sum=0;
       for (int i=0;i<a.length;i++){//将a数组的数全部循环出来
            sum+= a[i];//将a数组的数加上sum的数总和赋sum
          System.out.println("总和为："+sum);
      }  
  }

案例：查找最大值

 public static void main(String[] args){
  int[] a={1,2,3,4,5,6,7,8};
      int max =a[0];
       for (int i=0;i<a.length;i++){//将a数组的数全部循环出来

            if(a[i]>max){//如果a[i]数组的数大于max数往下执行
            max= a[i];//将a[i]大于max的数赋值给max
            }
            }
          System.out.println("最大值为："+max);
      
  }

进阶版

2. for- Each 循环

案例：打印全部的数组元素

 public static void main(String[] args){
  int[] a={1,2,3,4,5,6,7,8};
      for (int i:a){//将a数组的数全部循环出来
          System.out.println([i]);
      }   
  }

3. 数组作方法入参

案例：打印全部的数组元素

 public static void main(String[] args){
  int[] a={1,2,3,4,5,6,7,8};
                  k(a);
        }
        public static void k(int[] a){
            for (int i:a){//将a数组的数全部循环出来
                System.out.println(a[i]);
            }
        } 
  }

4. 数组作返回值

案例：反转数组（将数组的数倒着输出）

public class 小白 {

        public static void main(String[] args){
            int[] a={1,2,3,4,5,6,7,8};

           int [] b=b(a);//将反转的数给a数组
             q(b);//用q方法打印b方法反转的数——输出

        }

       //反转方法
    public static int [] b(int []a){
            int [] c = new int [a.length];//新建一个c数组【将a数组的长度给c数组】
              //当j等于c数组第7个，j--;i等于a数组第零个,i++
            for(int i = 0, j=c.length-1;i<a.length;i++,j--){
               c[j]= a[i];//将a数组第零个数给c数组第七个
            }
            return c;//返回c数组的数

        }
        //打印全部的数组元素
    public static void q(int[] a) {

        for (int i = 0; i<a.length; i++) {//将a数组的数全部循环出来
            System.out.print(a[i]+" ");
        }
    }
    }

六. 多维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是数组。
  • 二维数组
int a [][] = new  int[2][5];
  • 解析：以上二维数组可以看成一个两行五列的数组。
    思考：多维数组的使用？
    案例：
public class 小白 {
        public static void main(String[] args){
         int [][] a= {{1,2},{3,4},{5,6},{7,8}}
          System.out.println(a[0][0]+","+a[0][1]);
        }
   }
   输出：1，2

看图理解：
在这里插入图片描述

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

                    int [][] a= {{1,2},{3,4},{5,6},{7,8}};
                    q(a[0]);//输出：a数组的第零个
                    }
        //打印全部的数组元素
    public static void q(int[] a) {

        for (int i = 0; i<a.length; i++) {//将a数组的数全部循环出来
            System.out.print(a[i]+" ");
        }
    }
    }
    输出：1 2

案例数组的长度

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

                 int [][] a= {{1,2},{3,4},{5,6},{7,8}};
            System.out.println(a.length);
            System.out.pritln(a[0].length); 
                 }
 }
 输出：4    2

案例：输出全部的数组的数

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

                 int [][] a= {{1,2},{3,4},{5,6},{7,8}};
         for(int i = 0; i<a.length;i++){
         for(int j=0; j<a[0].length;j++){
            System.out.pritln(a[i][j]); 
            }
            }
                 }
 }
 输出：1 2 3 4 5 6 7 8

不理解看图理解

七. Arrays类

  • 数组的工具类Java.util.Arrays
  • 重点：学会查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法没在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：不用而不是不能）
  • 常用功能：给数组赋值：通过fill方法
  • 对数组排序：通过SORT方法，按升序。
  • 比较数组：通过equals方法比较数组中元素值是否相等。
  • 查找数组元素：通过binarySearch方法能对排序号的数组进行二分查找法操作。

类Arrays使用

import java.util.Arrays;

public class 类Arrays使用 {
    public static void main(String[] args) {
        int a[]={2,4,546,56,67567,562562,65,7,23,56};
        //Arrays输出全部数组
        System.out.println(Arrays.toString(a));
    }
}

输出：[2, 4, 546, 56, 67567, 562562, 65, 7, 23, 56]

自己也可以这样写：

import java.util.Arrays;

public class 类 {
    public static void main(String[] args) {
        int a[] = {2, 4, 546, 56, 67567, 562562, 65, 7, 23, 56};
        b(a);
    }

    public static void b(int a[]) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
            }
            if (i == a.length - 1) {
                System.out.print(a[i] + "]");
            } else {
                System.out.print(a[i] + ", ");
            }

        }
    }
}
输出：[2, 4, 546, 56, 67567, 562562, 65, 7, 23, 56]

Arrays对数组排序

import java.util.Arrays;

public class 类Arrays使用 {
    public static void main(String[] args) {
        int a[]={2,4,546,56,67567,562562,65,7,23,56};
      Arrays.sort(a);//从小到大排序
      System.out.println(Arrays.toString(a));
    }
}
输出：[2, 4, 7, 23, 56, 56, 65, 546, 67567, 562562]

Jdk文档去了解其他方法

八. 冒泡排序简介(从小到大排序）

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个
package com;

import java.util.Arrays;

public class Arraysdome1 {
    public static void main(String[] args) {
        int [] a={1234,63,6236,4,23567,34,56,2};
        int [] m=m(a);
        System.out.println(Arrays.toString(a));
    }
        public static int[]  m(int[] a){
        //临时变量
        int temp =0;
        //外层循环，判断我们要走多少次
        for (int i = 0; i <a.length-1; i++) {
            //内层循环，比价判断两个数，如果第一个数，比第二个数大，则交换位置

                for (int j= 0; j<a.length-1; j++) {
                    if(a[j+1]>a[j]) {
                        temp= a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;

                    }
                }

            }
        return a;
        }

        }

在这里插入图片描述

九. 稀疏数组

  1. 概念
    当一个中大部分元素为零时，或者为同一个值的数组时。
  2. 处理方法　
    （1）记录数组有几行几列，有多少个不同的值。
    （ 2）把具有不同值的元素的行列值记录在一个小规模数组中，而缩小程序的规模
  3. 原数组如下：
    在这里插入图片描述
  4. 转换为稀疏数组如下：
    在这里插入图片描述

案例

public void SparseTest() {
    // 创建一个原始的二维数组 11 * 11
    // 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
    int[][] arr = new int[11][11];
    arr[1][1] = 1;
    arr[2][3] = 2;
    arr[4][5] = 2;
    System.out.println("原始数组");
    for (int[] tmp:arr) {
        for ( int t : tmp) {
            System.out.printf("%d\t",t);
        }
        System.out.println();
    }

    int[][] sparseArr=ArrayToSparse(arr);
    //1.0输出稀疏数组
    System.out.println("输出稀疏数组");
    for (int i = 0; i < sparseArr.length; i++) {
        System.out.printf("%d\t%d\t%d\t",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        System.out.println();
    }
    //2.0 将系数数组写入文件
    WriteSparseToFile(sparseArr,"xishu.txt");

    //3.0从文件中读出稀疏数组
    System.out.println("从文件中读出稀疏数组");
    int[][] readFileArray = ReadFileToArray("xishu.txt");
    for (int i = 0; i < sparseArr.length; i++) {
        System.out.printf("%d\t%d\t%d\t",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        System.out.println();
    }
    //4.0从文件中读出稀疏数组,恢复成原来数组
    System.out.println("恢复出来的二维数组");
    int[][] ints = SparseToArray(readFileArray);
    for (int[] tmp:ints) {
        for ( int t : tmp) {
            System.out.printf("%d\t",t);
        }
        System.out.println();
    }
}

数组就学到这里！

余神
关注
专栏目录
java小白入行面试总结——基础篇
weixin_45417573的博客
11-04 491
java小白入行面试总结——基础篇 一、集合 关于集合，我们首先要关注的就是其继承体系（如图） 如上图，大致说明了关于collection和map派系集合的结构（注意：这里并不是其完整的继承体系，仅仅表述大致继承结构）。集合大致可以分为collection和map两个派系，而collection派系下又可分为list派系和set派系，我们简单的认为list派系代表有序的，可重负的集合，而se...
最大子段和问题--蛮力法、分治法、动态规划(Java代码)
suelta_th的博客
03-26 4149
最大子段和问题 给定由n个整数组成的序列（a1,a2,...,ana_1,a_2,...,a_na1​,a2​,...,an​）,求该序列形如 ∑k=ijak\sum\limits_{k=i}^j a_kk=i∑j​ak​的子段和的最大值，当所有整数均为负整数时，其最大子段和为0。 问题分析 简单的说就是求一个序列中截取一段连续的序列，要求截取的序列的和为最大值。 举例： 如序列为（-5,8,1...
java笔记 异常处理
yogur_father的博客
10-05 164
一.系统自动抛出异常 public class test { public static void main(String args[]) { int a[] = {1, 2, 3}; int sum = 0; int n = 0; // 分母 double ave = 0; try { for(int i = 0; i <= 3; i++) .
public static void main(String[] args)的说明
mature_77的博客
02-27 1529
public static void main(String[] args)的说明 public 访问权限 static 静态方法 void 无返回值 main java中所有程序的入口。。。 String[] args 终端界面的输入字符串参数 一个类中可以有多个main方法，但是。。 ** 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如...
最近做的一道随机问题，好像是int a[]={1,2,3,4,5,6,7,8,9}; 输出一个随机数组a[]={5,8,7,9,1,4,6,2,3};
aakzhangliangming的专栏
10-30 6403
开始感觉也好难，现在认真想一下，其实也比较简单，这里我用一个list来帮我解决随机数产生重复的问题。 看代码： import java.util.ArrayList; import java.util.List; import java.util.Random; public class RandomTest { /** * @param args */
数组作业及答案
weixin_39571268的博客
04-24 6832
一、填空题 1.数组会在内存中开辟一块________的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。 2.要获取一个数组的长度，可以通过________属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。 3._________仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。...
Java数组——学习笔记（4）
qq_43300979的博客
04-20 557
数组：存储同种数据类型的内存区域。 使用数组，不需要定义大量变量，实现业务功能简单。 一、定义数组 1、静态初始化数组：定义的时候给赋值 package com.laogao.practice; public class JavaPractice { public static void main(String[] args) { // 数组 // 格式 String[] s1=new String[]{"a","b","c"}; //
四、数组——小白秃头史05
javalimou的博客
12-18 99
四、数组 1.数组的概念 数组是一种容器，可以同时存放多个数据值 2.数组的特点 1.数组是一种引用数据类型 2.数组只能储存是同一种数据类的多个数据 3.数组的长度在此程序运行期间不可改变 3.一维数组 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。 1.动态初始化 动态初始化（指定长度），在创建数组的时候指定元素的个数 格式：数据类型[] = new 数据类型[数组长度]; int[] array = new int[6]; 2.静态初始化 静态初始化（指定内容），在创建数组的时候自
java小白学数组——第三关（青铜挑战）
zywmac的博客
12-04 178
我们先要搞清楚几个基本概念，在很多地方都会看到线性结构、线性表这样的表述，那什么是线性结构？与数组、链表等有什么关系？常见的线性结构又有哪些呢？ 所谓线性表就是具有相同特征元素的一个有限序列，其中所含元素的个数称为线性表的长度，从不同的角度看，线性表也有不同的分类，
Java初学者——小白篇（一）
抱着药罐子的博客
08-22 1078
本文简单介绍了Java环境的安装，以及Java数据类型的组成情况。
从C语言到Java——二者数组区别
进击的小白
10-21 1365
@[TOC]初学见解，不足之处有劳前辈们指点一二。 C语言和Java数组的区别 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 相同之处： 声明数组的同时可以直接赋值： C: int str[] = {1,2,3,4,5}; Java: int[] = {1,2...
java小白——输入一个随机数一维数组并输出最大值和最小值
weixin_45174208的博客
11-10 1643
package qaq; import java.util.Scanner; public class qaq22 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner sc = new Scanner(System.in); System.out.prin...
Java基础学习——数组（4、数组的基本操作：遍历数组，填充替换数组元素，对数组进行排序，复制数组，数组查询）
weixin_47030183的博客
03-10 840
4、数组的基本操作 1、遍历数组 遍历数组就是获取数组中的每个元素。通常遍历数组都使用for循环来实现。 遍历一维数组很简单，遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度。 在遍历数组时，使用foreach语句可能更简单。 代码演示： package com.company.day8; public class day82 { public static void main(String[] args){ int[][] a = new int[]
Java基础学习——数组（5、数组排序算法：冒泡排序，直接选择排序，反转排序）
weixin_47030183的博客
03-11 309
5、数组排序算法 1、冒泡排序 基本思想： 冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。 算法实现理念： 冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。 算
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1266
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1047
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 512
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1235
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
最新发布
2301_79272475的博客
10-30 395
Java复习24（PTA)：多种排序的book类*
Java数组知识总结与应用技巧
9. 数组的默认值 在Java中，基本类型数组元素有默认值（如int默认值为0，boolean默认值为false），对象数组元素的默认值为null。 Java数组总结这部分内容涵盖了Java数组的基本知识和操作。在实际编程中，数组是一种...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值