Java数组常用操作

最新推荐文章于 2023-03-26 20:14:38 发布
最新推荐文章于 2023-03-26 20:14:38 发布
阅读量1.3k 收藏 3
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44040018/article/details/116544049
版权

一维数组

  • 数组赋值
  • 数组翻转
  • 数组扩容
  • 数组缩减
  • 数组排序（冒泡排序）
  • 数组查找
  • 数组扩容后添加元素（在最后）

二维数组

  • 数组静态初始化
  • 数组动态初始化
  • 杨辉三角

数组初始化三种方式
数组动态初始化1

double[] a = new double[3];

数组动态初始化2

double[] a; //声明数组
a = new double[3]; // 分配空间

数组静态初始化（值有限）

double[] a = {3, 5, 1, 3.4, 2, 50};

两种打印a-z方式

public class CyclePractice{
	public static void main (String[] args){
		char[] apha = new char[26];
		for (int i = 0 ;i < 26; i++){
			apha[i] = (char)('a' + i); 
			System.out.print(apha[i]);
		}
	}
}

在这里插入代码片

在这里插入图片描述

public class CyclePractice{
	public static void main (String[] args){
		char[] apha = new char[26];
		apha[0] = 'a';
		System.out.print(apha[0]);
		for (int i = 0 ;i < 25; i++){
			apha[i+1] = (char)(apha[i] + 1); 
			System.out.print(apha[i+1]);
		}
	}
}

值传递和引用传递
值传递：简单把值给对方
引用传递： 把房子给对方

数组逆序（三种情况）

【只有arr1 不开辟新房子】仅仅输出逆序，数组实际没有逆序

public class CyclePractice{
	public static void main (String[] args){
		double[] arr1 = {3, 5, 1, 3.4, 2, 50};
		for (int i = arr1.length - 1; i >= 0 ;i--){
			System.out.println(arr1[i]);
		}
	}
}

【arr1 不开辟新房子】：原数组位置交换后的逆序

public class CyclePractice{
	public static void main (String[] args){
		double[] arr1 = {3, 5, 1, 3.4, 2, 50};
		int len = arr1.length;
		double temp = 0;
		for (int i = 0; i < len/2 ;i++){
			temp = arr1[len - 1 - i];
			arr1[len - 1 - i] = arr1[i];
			arr1[i] = temp;
		}
}

【arr2 开辟新房子】：开辟了新数组，为原数组的逆序

public class CyclePractice{
	public static void main (String[] args){
		double[] arr1 = {3, 5, 1, 3.4, 2, 50};
		double[] arr2 = new double[arr1.length];
		for (int i = 0 ; i < arr1.length ;i++){
			arr2[i] = arr1[arr1.length - 1 - i];
			System.out.println(arr2[i]);
		}	
	}
}

【arr2 开辟新房子】：开辟了新数组，原数组指向新数组

arr1 = arr2 ;
旧数组空间被JVM回收

数组扩容
思路，新建一个比原来大m的数组，把原数组数据放到新数组中，新数据添加到新数组中，旧数组指向新数组。

  1. 添加一个指定数据
public class ArrayAdd{
	public static void main (String[] args){
		double[] arr1 = {3, 5, 1, 3.4, 2, 50};
		double[] arr2 = new double[arr1.length + 1];
		for (int i = 0 ; i < arr1.length ;i++){
			arr2[i] = arr1[i];
		}
		arr2[arr1.length] = 8;
		arr1 = arr2;
		for (int i = 0 ; i < arr1.length ;i++){
			System.out.println(arr1[i]);
		}
	}
}
  1. 添加多个固定数据
import java.util.*;
public class ArrayAdd{
	public static void main (String[] args){
		Scanner scanner = new Scanner(System.in);
		String in = scanner.next();
		double[] arr1 = {3, 5, 1, 3.4, 2, 50};
		do{
			double[] arr2 = new double[arr1.length + 1];
			for (int i = 0 ; i < arr1.length ;i++){
				arr2[i] = arr1[i];
			}
			arr2[arr1.length] = 8; //添加固定数据8 
			arr1 = arr2;
			for (int i = 0 ; i < arr1.length ;i++){
				System.out.println(arr1[i]);
			}
			in = scanner.next();
		}while("y".equals(in));	
	}
}

在这里插入图片描述
3. 添加多个用户输入数据

import java.util.*;
public class ArrayAdd{
	public static void main (String[] args){
		Scanner scanner = new Scanner(System.in);
		String in = scanner.next();
		double[] arr1 = {3, 5, 1, 3.4, 2, 50};
		do{
			double[] arr2 = new double[arr1.length + 1];
			for (int i = 0 ; i < arr1.length ;i++){
				arr2[i] = arr1[i];
			}
			double myAdd = scanner.nextDouble(); //接收用户输入数据
			arr2[arr1.length] = myAdd; // 添加到arr2的最后一个位置
			arr1 = arr2;
			for (int i = 0 ; i < arr1.length ;i++){
				System.out.println(arr1[i]);
			}
			in = scanner.next();
		}while("y".equals(in));	
	}
}

在这里插入图片描述
4. 动态缩减数组
缩减一个

public class ArrayReduce{
	public static void main (String[] args){
		int[] arr = {1,2,3,4,5};
		int len = arr.length;
		int[] arr2 = new int[len - 1];
		for (int i = 0 ; i < arr2.length ; i++){
			arr2[i] = arr[i];
		}
		arr = arr2;
		for (int i = 0 ; i < arr2.length ; i++){
			System.out.println(arr[i]);
		}
	}
}

缩减到只有一个元素

import java.util.*;
public class ArrayReduce{
	public static void main (String[] args){
		Scanner scanner = new Scanner(System.in);
		String in = "";
		int[] arr = {1,2,3,4,5};
		do{
			int len = arr.length;
			int[] arr2 = new int[len - 1];
			for (int i = 0 ; i < arr2.length ; i++){
				arr2[i] = arr[i];
			}
			arr = arr2;
			for (int i = 0 ; i < arr.length ; i++){
				System.out.println(arr[i]);
			}
			in = scanner.next();
		}while("y".equals(in) && arr.length > 1); 
		//for (int i = 0 ; i < arr.length ; i++){
		//		System.out.println(arr[i]);
		//}
	}
}
  1. 排序
    内部排序：加载到内存里（交换排序、选择排序、插入排序）
    外部排序：数据量太大，需要额外存储空间（合并排序、直接合并排序）

冒泡排序，每一轮排序冒出一个最大值放最右边，每一轮排序比较次数依次减一

写法1：添加cycle循环变量，每次循环4，3，2，1次。

public class BubbleSort{
	public static void main (String[] args){
		int[] arr = {98,87,76,54,65,43,32,1};
		int len = arr.length;
		int temp = 0;
		for (int cycle = len - 1 ; cycle > 0 ;cycle --){
			for (int i = 1; i < cycle ;i++){
				int front = i - 1;
				int last = i;
				if(arr[front] > arr[last]){
					temp = arr[front];
					arr[front] = arr[last];
					arr[last] = temp;
				}
			}
			for (int i = 0; i < len ;i++){
				System.out.print(arr[i] + " ");
			}
			System.out.print("\n");
		}
	}
}

{98,87,76,54,65,43,32,1}
结果

87 76 54 65 43 32 1 98
76 54 65 43 32 1 87 98
54 65 43 32 1 76 87 98
54 43 32 1 65 76 87 98
43 32 1 54 65 76 87 98
32 1 43 54 65 76 87 98
1 32 43 54 65 76 87 98

写法2：

for (int cycle = 0 ; cycle < len - 1 ;cycle ++){
			for (int i = 1; i < len - cycle ;i++){
				int front = i - 1;
				int last = i;
				if(arr[front] > arr[last]){
					temp = arr[front];
					arr[front] = arr[last];
					arr[last] = temp;
				}
			}
			for (int i = 0; i < len ;i++){
				System.out.print(arr[i] + " ");
			}
			System.out.print("\n");
		}

87 76 54 65 43 32 1 98
76 54 65 43 32 1 87 98
54 65 43 32 1 76 87 98
54 43 32 1 65 76 87 98
43 32 1 54 65 76 87 98
32 1 43 54 65 76 87 98
1 32 43 54 65 76 87 98

优化：
待补充

  1. 查找

  • 顺序查找

  • 二分查找（待补充）

顺序查找

import java.util.*;
public class SeqSearch{
	public static void main (String[] args){
		String[] names = {"Tom0", "Tom1", "Tom2", "Tom3", "Tom4"};
		Scanner scanner = new Scanner(System.in);
		String input = scanner.next();
		int flag = -1;
		for(int i = 0 ; i < names.length ; i++){
			if(names[i].equals(input)){
				System.out.print("We have found the name.");
				flag = 1;
			}
		}
		if (flag == -1){
			System.out.print("We have not found the name.");
		}
	}
}

结果

D:\College\Javacode>java SeqSearch
Tom3
We have found the name.
D:\College\Javacode>java SeqSearch
Toms
We have not found the name.

二维数组
基本内容
数组静态初始化

public class TwoDemensionArray{
	public static void main (String[] args){
		int[][] arr = {{1,2,3,4,5},
						{6,7,8,9,10},
						{11,12,13,14,15,16}};
		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.print("\n");
		}
	}
}

数组动态初始化

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

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

import java.util.*;
public class TwoDemensionArray{
	public static void main (String[] args){
		int[][] arr = new int[3][];
		for (int i = 0; i < arr.length ; i++){
			arr[i] = new int[i + 1];
			for (int j = 0; j < arr[i].length ; j++){
				arr[i][j] = i + 1;
			}
			for (int j = 0; j < arr[i].length ; j++){
				System.out.print(arr[i][j] + "\t");
			}
			System.out.print("\n");
		}
	}
}

1
2 2
3 3 3

exercise ：打印杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
观察，发现如果arr[x][0]恒为1，arr[x][x]恒为1，其他情况arr[m][n]的值是它脑袋上的+他脑袋上左边的数。

import java.util.*;
public class TwoDemensionArray{
	public static void main (String[] args){
		int[][] arr = new int[6][];
		for (int i = 0; i < arr.length ; i++){
			arr[i] = new int[i + 1];
			for (int j = 0; j < arr[i].length ; j++){
				if(j == 0 || i == j){
					arr[i][j] = 1;
				}else{
					arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
				}
			}
			for (int j = 0; j < arr[i].length ; j++){
				System.out.print(arr[i][j] + "\t");
			}
			System.out.print("\n");
		}
	}
}

之前没搞懂的点：此时，x是一维数组，y是二维数组

int[] x, y[];

布尔类型数组没有赋值时，默认为false

exercise:已知一个升序数组要求加入一个元素后，仍为升序=》
int[] arr = {10, 12, 23, 45, 90};

public class ArrayAddSort{
		public static void main (String[] args){
			int[] arr = {10, 12, 45, 90};
			int add = 100;
			int flag = -1;
			int[] arr2 = new int[arr.length + 1];
			for (int i = arr.length - 1 ; i >= 0 ; i--){
				if(add > arr[i]){
					arr2[i] = arr[i];
					break;
				}else{
					arr2[i+1] = arr[i];
					arr2[i] = add;
					flag = 1;
				} 
			}
			//if add is bigger than all the nums in arr, then add
			// it in the end.
			if(flag == -1){
				arr2[arr.length] = add;
			}
			arr = arr2;
			for (int j = 0; j < arr.length ; j++){
				System.out.print(arr[j] + " ");
			}
	}
}

0 12 23 45 90

一种值得学习的思路（双指针）
找到索引index后，复制在新的arr2里

for (int i = 0 ,j = 0 ; i < arr2.length ; i++){
	if(i != index){
		arr2[i] = arr[i];
		j++;
	}else{
		arr2[i] = add;
	} 
}
於升
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中double[]和Double[]内存占用分析
zzyymaggie的专栏
07-30 8055
在编写java算法时将Map的value从double[]修改为Double[]发现内存增长了很多，因此对double[]和Double[]内存占用情况进行了分析。 double数组内存占用为24+8N, Double对象数组内存占用为24+36N，可见当数据量大时，Double[]所占内存为double[]的4.5倍，因此当数据量大时采用Double[]会导致数据量暴涨。
Java常用类之Double类
weixin_43520256的博客
10-03 1458
Double浮点型类 Double类对应基本类型double Double类中的常量 代码如下： /** * */ package CommonClasses; /** * @Description Double类中常量 * @author 枳洛淮南 * @version 1.0 * @Date 2020年10月2日下午9:44:28 */ public class DoubleConstant { public stat
呦吼~ 由来更新了！Java基础（四）大神教你学数组！快来看一看啊！！！
mnyketang02的博客
09-22 215
【码牛云课堂】Java基础（四）大神教你学数组！快来看一看！ 本贴为持续更新贴！内容附带大量图文和练习，供大家学习时参考。本贴主要内容为数组，希望大家阅读后能对数组有不少的了解。更多资料请练习： 码牛云课堂Java技术指导霸牛老师（微信）：mnykt8080； ​ 码牛云Java技术交流QQ群：1142264605； 1.数组 1.1为什么要学习数组？ 概念：数组就是一种容器，可以同时存放多个数据值。 数组的特点： 数组是一种引用数据类型 数组当中的多个数据，类型必须统一 数组的长度(数组中可以存储元素的
Java中关于double、Double相关问题总结
热门推荐
忆往昔的博客
10-18 1万+
Java中Double问题详解
Java double 二维数组实现
mysterious_9527的专栏
10-16 2413
由于业务需求，想实现[[12.12,31.2],[5.1,6.2],[7.1,2.7]]这种二维数组，java实现方式如下: public class Test { public static void main(String args[]) { List<Line> list = new ArrayList<Line>(); Line l1 = new Line(); Pi p1 = new Pi(); p1.setLat(11); p1.setLo.
9个java数组常用操作实例
08-25
"Java数组常用操作实例" 在Java编程中，数组是一种最基本的数据结构，掌握数组的常用操作对提高编程效率和代码质量至关重要。在本文中，我们将详细介绍九个Java数组常用操作实例，帮助读者快速掌握数组的基本操作。...
java基础之数组常用操作总结(必看篇)
08-30
Java数组常用操作总结 Java数组是Java编程语言中的一种基本数据结构，它可以存储相同类型的多个元素。数组是Java编程中的基础知识，掌握数组的操作是Java开发者的必备技能。本文将总结Java数组中的常用操作，包括求...
JAVA数组常用函数介绍及实例.docx
最新发布
06-28
### JAVA数组常用函数详解 #### 一、概述 在Java编程语言中，数组是一种非常基础且重要的数据结构，用于存储相同类型的数据集合。为了方便操作和管理数组中的数据，Java提供了一系列内置的方法来帮助开发者更高效...
深入了解Java数组操作及常用算法题
07-15
本文介绍了如何使用Java数组进行常见操作，并深入了解了一些常用的算法。通过对题目代码的分析和解决方案的说明，我们了解了每个操作的实现方法和作用。掌握这些数组操作和算法对于编写高效的Java程序非常重要，它们...
Java_int、double型数组常用操作工具类(分享)
08-29
Java_int、double型数组常用操作工具类 Java_int、double型数组常用操作工具类是 Java 语言中的一种常用工具类，用于操作 int 和 double 型数组。该工具类提供了多种常用的数组操作方法，包括获取数组的最大值、...
第3章 数组及字符串操作
背包客
09-20 611
数组及字符串操作
java入门---数组声明&创建&初始化&arrays类
luyaran的博客
05-02 2661
    数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。我们可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。这次我们来看Java 数组的声明、创建和初始化。    首先必须声明数组变量，才能在程序中...
1.2 一维数组的定义、赋值和初始化
you can you up up up的博客
09-21 6402
当数组中每个元素都只带有一个下标时，这种数组就是“一维数组”。一维数组（one-dimensional array）实质上是一组相同类型数据的线性集合，是数组中最简单的一种数组。 数组是引用数据类型，引用数据类型在使用之前一定要做两件事情：声明和初始化。所以本文将重点介绍一维数组的创建、初始化和使用。 创建一维数组 为了在程序中使用一个数组，必须声明一个引用该数组的变量，并指明整个变量可以引用的数组类型。声明一维数组的语法格式为： type[] arrayName; // 数据类型[] 数组名; 或
教你精通JavaSE语法之第六章、数组的使用
狼堡灰太狼的博客
03-26 418
JavaSE数组的知识点介绍，适用于初学者和有一定经验的学生进行学习和复习。
java 数组第一个位置插入_数组中实现指定位置插入数据。不用Arraylist
weixin_35414484的博客
02-23 1974
/***此方法只适合少量数据的数据插入操作*@authoryijie**/publicclassTest{staticint[]numArray={1,2,3,5,6,8,9};publicstaticvoidmain(String[]args){//4为5在数组的位置，可以用代码求我就不写了int[]numArray=insertInIndex...
【Java初阶】Array详解（上）
m0_56361048的博客
08-13 2610
一文带你学透数组（上）
数组
Chen_anan的博客
07-09 1062
数组的定义（三种）double [] a = new double[5];申请一个连续的内存单元，储存一批数据。String [] b = {"数组0","数组1","数组2","数组3","数组4"};int [] c = new int[]{1,2,3,4,5};访问数组元素：数组名+下标。但是注意数组的第一个下标是从0开始的，比如：数组中存5个数，那么他们的下标是[0,4];数组的本质：一组...
数组的使用及注意事项
qq_45821255的博客
07-26 1252
====== 数组的使用====== 一、三种使用方法 1、使用方式一：动态初始化 格式：数据类型[ ] 变量名 = new 数据类型[大小] 例：double[] hens = new double[5]； 使用方式一：动态初始化 double[] hens = new double[5]; Scanner myScanner = new Scanner(System.in); for(int i = 0 ; i < hens.length ; i++){ System.out
数组初始化
向南的博客
01-14 166
声明：double[] a；创建数组：a = new double[10]; 数组初始化：for(int i = 1;i &lt; 3;i++)         {             a[i] = 0.0;         } 声明并创建数组：double[] a = new double[n]; 声明并创建,初始化：double[] a = {1.2,1.3,1.0}; 获取数组 ...
java数组的常用方法
07-28
回答: Java数组的常用方法包括反转数组和打印数组。反转数组可以使用java.util.Arrays类中的reverse方法，例如int\[\] intArray={1,2,3,4,5}; Arrays.reverse(intArray); 可以将数组intArray反转为\[5,4,3,2,1\]。\[2\]打印数组可以使用Arrays类中的toString方法，例如int\[\] intArry={1,2,3,4,5}; String intArryString=Arrays.toString(intArry); System.out.println(intArryString); 可以将数组intArry打印出来。\[3\]除此之外，java.util.Arrays类还提供了其他一些常用的数组操作方法，可以根据具体需求进行使用。 #### 引用[.reference_title] - *1* [JAVA数组常用方法](https://blog.csdn.net/a1091220321/article/details/24178019)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [Java数组的常用方法](https://blog.csdn.net/qq_29224201/article/details/103074789)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值