Java数组

已于 2023-03-18 22:32:40 修改
阅读量77 收藏
点赞数 1
文章标签： 算法 排序算法 数据结构
于 2023-03-18 22:31:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76549115/article/details/129639853
版权

一维数组

数组作为对象允许使用new关键词进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。

一维数组的创建有两种形式。

先声明，再用new关键词进行内存分配

一维数组有下列两种形式。

数组元素类型     数组名字【】；

数组元素类型【】  数组名字；

分配内存空间

数组名=new    数组元素的类型

分配内存同时设置初始值

数组名=new   数组元素的类型【】{值1，值2，....,值3}

使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0.

数组元素赋值

数组【索引】=值；

数组名【】

 
public class GetDay {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
        //for循环遍历数组
        for(int i=0;i<12;i++){//利用循环将信息输出。 如改成”i<13“数组下标越界，会出现报错
            System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
        }
    }
 
}

 
public class GetDay {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
        //for循环遍历数组
        for(int i=0;i<day.length;i++){//利用循环将信息输出。 加length避免下标越界
            System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
        }
    }
 
}

 运行结果如下：

public class Foreach {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]= {5,13,96};//一维整型数组
        System.out.println("一维数组中的元素分别是：");
        //foreach循环遍历数组,避免下标越界
        //x的类型与arr元素的类型相同。for循环依次取出arr中的值并赋给x
        for(int temp:arr) {
            System.out.println(temp);//输出遍历出的元素值
            }
    }
 
}

二维数组

如果一组数组中的各个元素任然是一个数组，那么它就是一个二维数组，二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列

二维数组可以看作是特殊的一维数组，因此二维数组的创建同样有两种方式。

1.先声明，再用new关键字进行内存

分配元素的类型    数组名字【】【】；

数组元素的类型【】【】   数组名字；

2.内存分配

二维数组分配内存

new  数组元素的类型【行数】【列数】

二维数组分配内存同时设置初始值

数组名= new   数组元素的类型【】【】{{值1，值2，.....},{值1，值2.....},.............,{值1，值2......}};

初始化二维数组后，要明确数值的下标都是从0开始。

 
public class Matrix {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int a[][]=new int[3][4];//定义二维数组
        for (int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++) {//循环遍历数组中的每一个元素
        
        System.out.print(a[i][j]);//将数组中的元素输出
        }
            System.out.println();//输出空格
    }
 
}
}

 运行结果如下：

数组的基础操作

遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。

遍历二维数组需使用双层for循环，通过数组的length属性可获得数组长度。

在遍历数组时，使用foreach语句可能会更简单。

 
public class Tautog {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr2[][]= {{4,3},{1,2}};//定义二维数组
        System.out.println("数组中的元素是：");//提示信息
        int i=0;//外层循环计数器变量
        for(int x[]:arr2) {//外层循环变量为一维数组
            i++;//外层计数器递增
            int j=0;//内层循环计数器变量
            for(int e:x) {//循环遍历每一个数组元素
                j++;//内层计数器递增
                if(i==arr2.length&&j==x.length) {//判断变量是二维数组的最后一个元素
                    System.out.print(e);//输出二维数组的最后一个元素
                }else//如果不是二维数组的最后一个元素
                    System.out.print(e+"、");//输出信息
            }
        }
    }
 
}

 运行结果如下：

 替换数组

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型：

替换数组

Arrays.fill（数组名，值）；

替换数组部分元素:前改后不改

Arrays.fill(数组名，前索引，后索引，值）；索引=下标

填充替换数组元素

1.fill（int【】a，int value）

import java.util.Arrays;//导入java.util.Arrays类
 
public class Swap {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[5];//创建int型数组
        Arrays.fill(arr,8);//使用同一个值对数组进行填充
        for(int i=0;i<arr.length;i++) {//遍历循环数组中的元素
            System.out.println("第"+i+"个元素是:"+arr[i]);//将数组中的元素依次输出
        }
    }
 
}

 运行结果如下：

 2.fill（int【】a，int  fromlndex，int  tolndex，int  value）

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromlndex（包括）一直到索引tolndex（不包括）。如果fromlndex=tolndex，则填充范围为空。

import java.util.Arrays;//导入java.util.Arrays类
 
public class Displace {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {45,12,2,10};//定义并初始化int型数组arr
        Arrays.fill(arr,1,2,8);//使用fill()方法替换数组指定范围内的元素
        for(int i=0;i<arr.length;i++) {//循环遍历数组中的元素
        System.out.println("第"+i+"个元素是："+arr[i]);//将数组中的每个元素输出
    }
 
}
}

 运行结果如下：

 

 对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

Arrays.sort(object)

import java.util.Arrays;//导入java.util.Arrays类
 
public class Taxis {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,8};//声明数组
        Arrays.sort(arr);//将数组进行排序
        for(int i=0;i<arr.length;i++) {//循环遍历排序后的数组
            System.out.println(arr[i]);//将排序后数组中的各个元素输出
        }
    }
 
}

 运行结果如下：

 复制数组

1.copyOf（）方法

该方法提供了多种重载形式，用于满足不同类型数组的复制。语法如下：

copyOf（arr，int newlength）

复制数组：空位补0，溢出去掉

新数组名=Arrays.copOf(旧数组名，新数组长度)；

import java.util.Arrays;//导入java.util.Arrays类
 
public class Cope {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12};//定义数组
        int newarr[]=Arrays.copyOf(arr,5);//复制数组arr
        for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
            System.out.println(newarr[i]);//将新数组输出
        }
    }
 
}

 代码运行结果如下：

 2.copyOfRange（）方法

复制数组部分元素：前在后不在

新数组名=Arrays.copysOfRange（旧数组名，前索引，后索引）；

import java.util.Arrays;//导入java.util.Arrays类
 
public class Repeat {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,84,10};//定义数组
        int newarr[]=Arrays.copyOfRange(arr,0,3);//复制数组
        for (int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
            System.out.println(newarr[i]);//将新数组中的每个元素输出
        }
    }
 
}

 运行结果如下：

 查询数组

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

1.binarySearch（Object【】a，Object   key）

语法如下：

查询数组：先排序再查询

索引=Arrays.binrySearch（数组名，值）；

import java.util.Arrays;//导入java.util.Arrays类
 
public class Reference {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int ia[]=new int[] {1,8,9,4,5};//定义int型数组ia
        Arrays.sort(ia);//将数组进行排序
        int index=Arrays.binarySearch(ia,4);//查找数组ia中元素4的索引位置
        System.out.println("4的索引位置是："+index);//将索引输出
    }
 
}

运行结果如下:

2、binarySearch(Object[] a,int fromlndex,int tolndex,Objrct key)

该方法在指定的范围内检索某一元素。语法如下：

查询数组元素：先排序再查询，前含后不含

索引=Arrays.binrySearch(数组名，前索引，后索引，元素）

import java.util.Arrays;//导入java.util.Arrays类
 
public class Rakel {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        String str[]=new String[] {"ab","cd","ef","yz"};//定义String型数组str
        Arrays.sort(str);//将数组进行排序
        int index=Arrays.binarySearch(str,0,2,"cd");//在指定范围内搜索元素“cd”的索引位置
        System.out.println("cd的索引位置是："+index);//将索引输出
    }
 
}

 运行结果如下：

数组排序算法

1.冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

public class BubbleSort {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        BubbleSort sorter= new BubbleSort();//创建冒泡排序类的对象
        sorter.sort(array);//调用排序方法，对数组排序
    }
    public void sort(int[] array) {
        for (int i=1;i<array.length;i++) {
            //比较相邻两个元素，比较的元素往后冒泡
            for(int j=0;j<array.length-i;j++) {
                if(array[j]>array[j+1]) {
                    int temp=array[j];//把第一个元素值保存到临时变量中
                    array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
                    array[j+1]=temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
                }
            }
        }
        showArray(array);//输出冒泡排序后的数组元素
    }
    private void showArray(int[] array) {
        // TODO Auto-generated method stub
        for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
            
        }
        System.out.println();
    }
 
}

代码运行结果如下：

 2.直接选择排序

直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法

public class SelectSort{
 public static void main(String[] args) {
  int[] array= {63,4,24,1,3,15};//创建一个数组，元素是乱序的
  SelectSort sorter=new SelectSort();//创建直接排序类的对象
  sorter.sort(array);//调用排序对象方法，对数组排序
 }
 public void sort(int[] array) {
  int index;
  for(int i=1;i<=array.length;i++) {
   index=0;
  for(int j=1;j<=array.length-i;j++) {
   if(array[j]>array[index]) {
    index=j;
   }
  }//交换在位置array.length-i和inde(最大值）上的两个数
   int temp=array[array.length-i];//把第一个元素值保存到临时变量中
   array[array.length-i]=array[index];//把第二个元素值保存到第一个元素单元中
   array[index]=temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
 }
  showArray(array);//输出直接选择排序后的数组元素
}
 public void showArray(int[] array) {
  for(int i:array) {//遍历数组
   System.out.print(">"+i);//输出每个数组元素值
  }
  System.out.println();
 }
}

运行结果如下：

反转排序

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

public class ReverseSort {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int []array = {10,20,30,40,50,60};//创建一个数组
		ReverseSort sorter = new ReverseSort();//创建反转排序类的对象
		sorter.sort(array);//调用排序对象方法，将数组反转
	}
	
	public void sort(int[] array) {
		System.out.println("数组原有内容：");
		showArray(array);//输出排序前的数组元素
		int temp;
		int len = array.length;
		for (int i = 0;i<len/2;i++) {
			temp = array[i];
			array[i] = array[len-1-i];
			array[len-1-i] = temp;
		}
		System.out.println("数组反转后内容:");
		showArray(array);//输出排序后的数组元素
	}
	
	public void showArray(int[]array) {
		for(int i :array) {//遍历数组
			System.out.print("\t"+i);//输出每个数组元素
		}
		System.out.println();
	}

}

运行结果如下：

煦柒安
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
java数组
04-20
Java数组是程序设计中不可或缺的基础概念，它是一种数据结构，允许我们存储同类型的多个元素。在Java中，数组是对象，具有固定的大小，一旦创建，其长度就不能改变。本篇文章将深入探讨Java数组的各个方面，包括创建...
Java 数组
热门推荐
Naion的博客
03-22 2万+
本文章介绍了Java中数组的一些概念和一些方法的使用。
java数组倒序
weixin_46409629的博客
03-24 2618
java数组倒序
初始java数组
AgoniTop的博客
03-24 4840
1.初始化定义 2.数组的三种打印方式 3.数组引用null 4.浅谈引用变量的影响 5.与数组相关的字符串操作 以及javaJVM内存简单介绍 6.浅谈二维数组与C的区别
Java 数组删除一个元素
sxlzs_的博客
09-06 2474
根据下标删除一个数组元素。
java数组操作
wmy01234的博客
07-25 2148
java数组操作
Java数组类型
HHYZBC的博客
04-26 4908
数组的概述 数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。 数组的分类： 按照维度：一维数组、二维数组、三维数组、… 按照元素的数据类
JAVA数组去重方法
weixin_55076626的博客
03-20 1万+
当判断两个元素是否相同时，HashSet会先调用hashCode()方法比较它们的哈希值，如果哈希值不同，那么这两个元素也就不相同了；如果哈希值相同，还会继续调用equals()方法比较它们的值，如果equals()方法返回true，那么这两个元素即被视为相同元素，新元素就不能被添加进去。当向HashSet中添加元素时，HashSet会先计算元素的hashCode值，然后根据hashCode值将元素放入不同的桶(bucket)中。当多个元素放入同一个桶中时，它们会以链表的形式存储。
Java数组常用操作
Lilip_的博客
04-19 7655
 1.数组长度  2.数组填充  3.数组复制  4.数组比较  5.数组排序  6.在数组中搜索指定元素  7.把数组转换成字符串 数组的常用操作包括数组的充、复制、比较、排序等。Java提供了相应对数组的操作的系统函数（方法），利用系统函数（方法）可以对数组进行各种操作。 1、数组长度 数组长度指的是数组的大小，也就是数组包含元素的个数。如果想获得数组的长度，可以用其本身的 length 属性获得。使用方法就是在数组名后加 “.length”。代码如下： public class Main
Java数组输出
weixin_44824428的博客
12-28 2660
Java数组输出
java数组遍历 删除remove(示例代码)
09-04
在Java编程中，数组是一种基本的数据结构，用于存储固定数量的相同类型的数据。然而，当涉及到动态添加或删除元素时，数组并不方便，因为它在创建时必须指定长度，并且一旦创建，长度就不能改变。这时，我们可以转向...
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。了解和熟练掌握数组的使用是学习Java的重要环节。本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细...
初识JAVA数组
09-04
【初识JAVA数组】 在Java语言中，数组是一种基本的复合数据类型，它代表了有序数据的集合。数组的关键特性是其元素具有相同的类型，并且可以通过一个数组名称和下标来唯一地确定每个元素的位置。Java支持一维数组和...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 443
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 210
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 226
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
摩尔投票算法
qq_55846232的博客
07-14 469
摩尔投票算法的介绍以及相关例题的讲解
java 数组
05-30
Java 数组是一种用于存储同一类型数据的集合。它们是基本数据结构之一，非常重要，被广泛应用于各种算法和数据处理场景中。 Java 数组可以存储基本类型数据（如 int、float、double 等）以及对象类型（如 String、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值