Java数组

最新推荐文章于 2022-11-05 19:42:31 发布
最新推荐文章于 2022-11-05 19:42:31 发布
阅读量305 收藏
点赞数
文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49251636/article/details/119514182
版权

数组概述

在这里插入图片描述

数组声明创建

在这里插入图片描述

public class ArraryDemo01 {
    //变量的类型   变量的名字 =变量的值;
    //数组类型
    public static void main(String[] args) {
        int []nums;//1.定义
        int nums2[];//c与c++定义方法
    }
}


public class ArraryDemo01 {
    //变量的类型   变量的名字 =变量的值;
    //数组类型
    public static void main(String[] args) {
        int []nums;//1.定义
        nums=new int[10];//这里面可以存放10个int类型的数字   创建一个数组
        //给数组元素中赋值
        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;
        //不赋值会有一个默认值 int类型是0 string类型是null
        System.out.println(nums[9]);
        System.out.println(nums[8]);
        //计算所有元素的和
        int sum=0;
        //arrays.length数组的长度
        for (int i = 0; i <nums.length ; i++) {
            sum+=nums[i];
        }
        System.out.println("总和为："+sum);
    }
}




10
0
总和为：46

进程已结束，退出代码为 0

内存分析

在这里插入图片描述
在这里插入图片描述
当我们使用数组中不存在的下标时，则会报错
java.lang.ArrayIndexOutOfBoundsException
所以，当今后在编程过程中出现这样的错误，首先我么要想到是否是数组越界的问题。

数组使用

在这里插入图片描述

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化 :创建+赋值
        int [] a={1,2,3,4,5,6,7,8,9};
        System.out.println(a[0]);
        //动态初始化 包含默认初始化
        int [] b= new int[10];
        b[0]=20;
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);

    }

}

1
20
0
0
进程已结束，退出代码为 0

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class ArrayDemo03 {
    public static void main(String[] args) {
        int []arrays={1,2,3,4,5};
        //打印全部的数组元素
        for (int i = 0; i <arrays.length ; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=============================");
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i <arrays.length ; i++) {
            sum+=arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("=================================");
        //查找最大元素
        int max=arrays[0];
        for (int i = 1; i <arrays.length ; i++) {
            if (arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

运行结果：
1
2
3
4
5
=============================
sum=15
=================================
max=5


public class ArrayDemo04 {
    public static void main(String[] args) {
        int[]arrays={1,2,3,4,5};
        //JDK1.5，没有下标
//        for (int array : arrays) {
//            System.out.println(array);
//        }
        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.printf(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;
    }
}



运行结果
12345
54321

多维数组

在这里插入图片描述

public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
        1,2 array[0]
        2,3 array[1]
        3,4 array[2]
        4,5 array[3]
         */
        int[][]array={{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j < array[i].length; j++) {


                System.out.println(array[i][j]);
            }
        }
        printArray(array[0]);
        System.out.println();
        System.out.println(array[0][0]);
        System.out.println(array[0][1]);
        System.out.println(array[2][1]);
    }
    public static void printArray(int[]arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.printf(arrays[i]+" ");
        }
    }
}


运行结果：
1
2
2
3
3
4
4
5
1 2 
1
2
4

Arrays类

在这里插入图片描述
Array类中内置方法：
可通过ctrl+鼠标右键点击idea中的Array 选择右下角的结构选项中可查看到Array类中的内置方法。也可通过JDK帮助文档查看内置的方法，在这里就不多赘述了。
在这里插入图片描述

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 9090, 21231, 543, 21, 3, 23};
        System.out.println(a);
        //打印数组元素
        System.out.println(Arrays.toString(a));
        printArray(a);
        System.out.println();
        Arrays.sort(a);//数组进行排序 升序排序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
    }

    //不要重复造轮子
    public static void printArray(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] + ", ");
            }
        }
    }
}



运行结果：
[I@6d311334
[1, 2, 3, 4, 9090, 21231, 543, 21, 3, 23]
[1, 2, 3, 4, 9090, 21231, 543, 21, 3, 23]
[1, 2, 3, 3, 4, 21, 23, 543, 9090, 21231]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

不要过度依赖工具类，工具类中的方法也是人写出来的，我们也可以写出来，但是没有必要重复造轮子。刚开始学习的话，明白其中的基本原理即可。

Array类tostring方法源码

这是包中内置的tostring方法的源码，在这里给大家复制粘贴出来学习，可能很多同学在刚接触Java，不太能理解stringBuilder类，今后会给大家做一个详细的介绍。

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(", ");
        }
    }

冒泡排序

在这里插入图片描述
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置。
//2.每一次比较，都会产生出一个最大，或者最小的数字。
//3.下一轮，可以少一次排序!

 public static int[] sort(int []array){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个循环要走多少次；
        for (int i = 0; i <array.length-1 ; i++) {
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            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;
                }
            }
        }
        return array;
    }

如果要将降序改为升序，则将if (array[j+1]>array[j])中的大于号变成小于号即可，冒泡排序是一个非常重要的排序方法，所以希望大家可以课下多多练习，熟练并且掌握这一个排序方法，对于以后的学习或者是工作来说都有很好的帮助。

冒泡排序的一种优化方式——加入flag标识位

 public static int[] sort(int []array){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个循环要走多少次；
        boolean flag=false;//通过flag标识位减少没有意义的比较
        for (int i = 0; i <array.length-1 ; i++) {
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            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;
                    flag=true;
                }
            }
            if(flag==true){
                break;
            }
        }
        return array;
    }

*稀疏数组

在这里插入图片描述
在这里插入图片描述

代码实现稀疏数组

其中包含了稀疏数组的构建与稀疏数组的还原

public class ArrayDemo08 {
    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;
        //遍历二维数组，将非零的值，存放进稀疏数组中
        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();
        }
    }
}


输出原始的数组
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

特别感谢：

附上视频地址
狂神yyds
https://www.bilibili.com/video/BV12J41137hu?p=30

爱码代码的小陈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java数组代码
08-28
java数组代码
一个简单JAVA 数组代码
silence2015的专栏
10-06 968
private static void print(int[] arr)     {         for (int i : arr) {             System.out.print(i+" ");         }     } 其中
Java的数组代码
xuanyuanchun的博客
10-31 524
Java的数组 1.1-1.2 数据类型[] 数组名 数据类型 数组名[] 数据类型[] 数组名=new 数据类型[数组长度] Int[] arr={1,2,3,4}; Int[] arr =new int[10]; 数组长度 Int[] a={1,2,3,4,5,6,7,8,9,10}; Length表示数组长度 如a.length 2.1 数组：Array package com.imooc.flow1; public class ArrayDemo{ public static void main (
java数组源代码
08-21
java实现数组，java开发实战经典，李新华，继承的应用
java 数组 源码_Java Arrays 源码 笔记
weixin_35032861的博客
02-16 286
Arrays.java是Java中用来操作数组的类。使用这个工具类可以减少平常很多的工作量。了解其实现，可以避免一些错误的用法。它提供的操作包括：排序 sort查找 binarySearch()比较 equals填充 fill转列表 asList()哈希 Hash()转字符串 toString()这个类的代码量很多，Java1.7中有4000多行。因为每一种基本类型都做了兼容，所以整个类真正逻辑不...
java数组排序
09-04
java数组排序的思想，过程和代码实现。多种数组排序的方法，主要有冒泡排序，堆排序，插入排序， 归并操作(merge)， 归并操作(merge)，选择排序，希尔排序。
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
java数组遍历 删除remove(示例代码)
09-04
java数组遍历 删除remove。需要的朋友可以过来参考下，希望对大家有所帮助
Java数组讲解
06-02
//在定义数组时,如果确定数组的各个元素,可以进行静态初始化 ,在创建数组时,给数组元素赋初值 int [] data2 = new int[] {34,56,765,78}; //注意静态初始化时,不需要指定数组的长度 //通过foreach循环遍历, 增强的...
java数组自定义排序
10-31
java中数组的自定义排序，种类繁多，简单实现，可自由操控。
java数组测试源代码
05-25
java开发学习，数组测试，这是java初学者可以使用的java数组范例，简洁明了，很容易学习
Java数组相关的例子代码
08-12
Java数组相关的例子代码 Java数组相关的例子代码
JAVA数组
qq_46534049的博客
11-05 297
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,...,数据n};或者 数据类型 数组名[] = new 数据类型[]{数据1,数据2,...,数据n};（4） 整数类型的数组元素默认值0，浮点数类型的数组元素默认值0.0 char类型数组的数组元素默认值是空格，boolean类型数组的数组元素默认值false，引用数据类型的数组元素默认值为null。还有更简洁的方式：数据类型[] 数组名={数据1，数据2，....数据n}例如int[] nums1={1,2,3,4}；
Java：常见数组处理代码
等等waiting
08-21 695
package text1; import java.util.Arrays; import java.util.Scanner; public class Array { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner...
数组java代码
weixin_69863356的博客
09-25 144
/开辟新数组长度为两数组之和。i
java数组常用代码
不起眼的小孩
06-02 651
// int [] array = new int[10]; // Scanner input = new Scanner(System.in); // System.out.println(“请输入”+array.length+“个值：”); // for(int i=0;i<array.length;i++) // 循环输入数据 // { // array[i] =i...
java中的数组
m0_60633107的博客
05-01 301
了解java中的数组：一维数组、二维数组，数组基本操作
源码：Java集合源码之：数组与链表（一）
weixin_30906671的博客
05-30 189
数组和链表是数据结构中最基本的部分。 数组 在java中，数组定义为一种基本类型，其可以通过下标获取到对应位置的数据。那么这种结构的数据，在内存中是怎么存放的呢？ 数组在内存中是一段连续的存储单元，每个数据依次放在每个单元中。 分析这种结构，我们可以得出以下几个结论： 创建一个数组，必须声明其长度，以在内存中寻找合适的一段连续存储单元。这也意味着数组的大小...
数组中的代码实现.Java
weixin_42392831的博客
09-21 254
1.数组转字符串 import java.util.Arrays; public class Zuo{ public static void main(String[] args){ int[] arr = {1,2,3,4,5,6}; System.out.println(toString(arr)); } public static String toString(int[] arr){ St...
java 数组
最新发布
05-30
Java 数组是一种用于存储同一类型数据的集合。它们是基本数据结构之一，非常重要，被广泛应用于各种算法和数据处理场景中。 Java 数组可以存储基本类型数据（如 int、float、double 等）以及对象类型（如 String、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值