Java基础5--数组

最新推荐文章于 2023-03-03 02:14:48 发布
最新推荐文章于 2023-03-03 02:14:48 发布
阅读量503 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JOJOY_tester/article/details/77278929
版权

数组

jvm Java虚拟机

Java的虚拟内存4

栈区

存放函数的参数值，局部变量的值。存放Java基础类型：int double char等，从main()函数下面的变量是局部变量。

超过这个变量的作用域时就会被系统自动释放在jvm内存中的资源。这个是Java的一种垃圾回收机制。

在Python里面，也有垃圾回收机制，在类实例化后的实例对象，删除是会动用垃圾回收机制，__del__()方法。

超过变量作用域指：局部变量只能在某部分使用，如循环、判断内定义的变量，超过这个作用域变量就会失效。在哪个大括号声明的作用域就是这个大括号的范围

缺点：存在栈区中的数据的大小、生存周期必须是确定的，没有灵活性。

优点：存取速度很快

eg：

声明一个变量是放在栈内存中的。


堆区

存放由new创建的对象和数组，存放引用类型的

jvm会不定时查看这个对象，若果没有引用只想这个对象就回收。(垃圾回收)

new Scanner（System.in）、new Random（）等；

缺点：要在运行是分配jvm内存；

优点：可以动态分配jvm内存；

静态区


代码区


数组3

存放一组相同类型的数据的对象；

Python中list是数组，但是存放任何类型的数据都行；

使用数组：

1.声明数组

int[] a;

2.分配空间

a = new int[5];  创建长度为5.

3.赋值

a[0] = 1;

4.处理数据

a[0] = a[0]*5

eg：

package list;

public class listTest1 {
	public static void main(String[] args){
		int[] list;         //声明一个数组变量list，存放在栈区
		list = new int[5];  //分配5个地址空间，也就是数组的长度  ,存放在堆区
		list[0] = 1;        //给空数组的第一个地址空间赋值
		list[1]=2;
		list[2]=3;
		list[3]=4;
		list[4]=5;
		System.out.println(list[0]);   //访问数组的第一个地址空间
		System.out.println(list[4]);
				
	}
}
数组赋值的几种方式：
package list;
import java.util.*;
public class listTest2 {
	public static void main(String[] args){
		//使用数组几种方法
		int[] arr = new int[5];//声明数组变量，并赋予5个地址空间
		arr[0]=9;
		arr[3]=8;
		System.out.println(arr[3]);
		
		//数组一次性赋值
		int[] list={1,2,3,4,5}; //声明数组list并赋值1 2 3 4 5
		System.out.print(list[0]);
		
		int[] list1 =  new int[]{1,22,3,4,5};
		System.out.print(list1[2]);
		
		//用户输入的内容保存在数组中
		int[] list2 = new int[5];
		Scanner in = new Scanner(System.in);
		for(int i=0;i<=4;i++){
			System.out.println("请输入第"+i+"个元素：");
			list2[i]=in.nextInt();
		}
		System.out.println(list2[4]);
		
	}
}

声明int类型的数组但是没有赋值的话，Java自动给初始值为0；

声明char、String类型的数组，没有赋值，Java自动给初始值null；

package list;
import java.util.*;
public class listTest3 {
	public static void main(String[] args){
		/*
		Scanner in = new Scanner(System.in);
		int list1[] = new int[2];
		list1[0] = 1;
		list1[1] = 2;
		for(int j=1;j<=2;j++){
			System.out.println("请输入：");
			list1[j] = in.nextInt();
		}
		//2*
		double list2[] = {1.2,1.4};*/
		int i [] =new int[3];
		System.out.println(i[1]);
		if(i[1] == 0){
			System.out.println("int类型数组，声明不赋值，默认是0");
		}
		
		String s[]=new String[3];
		System.out.println(s[1]);
		if(s[0] == null){
			System.out.println("这个是null啊");
		}

	}
}
将用户输入的内容保存到数组中
package list;
import java.util.*;
public class listTest_avg {
	public static void main(String[] args){
		double sum=0;
		Scanner in = new Scanner(System.in);
		double[] score = new double[3];
		for(int i = 0;i < 3;i++){
			System.out.println("请输入第"+(i+1)+"个学生的成绩");
			score[i] = in.nextInt();
			sum = sum+score[i];
		}
		System.out.println("3个学生的平均成绩是"+sum/3);
	}
}

数组的属性--length  

list.length   ====>获取数组的长度

package list;
import java.util.*;
public class listTest_avg {
	public static void main(String[] args){
		double sum=0;
		Scanner in = new Scanner(System.in);
		System.out.println("请输入学生个数：");
		int student = in.nextInt();
		//声明数组score，长度用户自定义
		double[] score = new double[student];
		//遍历数组，为数组每一个元素赋值，使用length获取长度
		for(int i = 0;i < score.length;i++){
			System.out.println("请输入第"+(i+1)+"个学生的成绩");
			score[i] = in.nextInt();
			sum = sum+score[i];
		}
		System.out.println("3个学生的平均成绩是"+sum/score.length);
	}
}

数组求最大值

eg：

自定义输入几个数，然后输出最大值:

package list;
import java.util.*;
public class listMax1 {
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		System.out.println("请输入统计的学生成绩个数：");
		int num = in.nextInt();
		double score[] = new double[num];
		for(int i =0;i< score.length;i++){
			System.out.println("请输入第"+(i+1)+"个学生的成绩！");
			score[i] = in.nextDouble();
		}
		double max = score[0];
		for(int i=0;i<score.length;i++){
			if(max<score[i]){
				max = score[i];
			}
		}
		System.out.println("成绩最高的分数是"+max);
	}
}


操作数组的方法

Java中java.util包，提供许多储存数据的结构和方法；

Scanner、Random、Arrays

Arrays类提供许多操作数组的方法：排序、查询等

数组升序4

对数组里面数据进行升序排序：

Arrays.sort(数组);

eg：

使用例子：输入10个数，然后升序后输出

package list;
import java.util.Scanner;
import java.util.Arrays;
public class listSort1 {
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		System.out.println("请输入计算的数量：");
		int num = in.nextInt();
		int list1[] = new int[num];
		for(int i =0;i <list1.length;i++){
			System.out.println("请输入第"+(i+1)+"个元素！");
			list1[i] = in.nextInt();
		}
		//对数组list1进行升序排列
		Arrays.sort(list1);
		//循环遍历数组输出
		for(int i=0;i< list1.length;i++){
			System.out.println(list1[i]);
		}
	}
}

数组逆序输出4

代码：先使用Arrays.sort()实现升序功能，再往前输出就实现降序功能了

package list;
import java.util.*;
public class listSort2 {
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		System.out.println("请输出计算的个数：");
		int num = in.nextInt();
		String list2[] = new String[num];
		for(int i=0;i<list2.length;i++){
			System.out.println("输入第"+(i+1)+"个数");
			list2[i] = in.next();
		}
		//对数组进行升序排列
		Arrays.sort(list2);
		//对数组进行降序排列,先获取最后一个元素，在往回一个一个输出，就能实现降序了
		for(int i=list2.length-1;i>=0; i--){
			System.out.println(list2[i]);
		}
	}
}
数组的复制算法

数组复制算法：主要是通过for循环遍历，一个个赋值到B数组就行

//数组的复制算法
package list;

public class listfuzhi {
		public static void main(String[] args){
			//数组复制算法：主要是通过for循环遍历，一个个赋值到B数组就行
			int list1[] = {1,2,3,4,5,6,7,8};
			int list2[] = new int[list1.length];
			for(int i =0;i<list2.length;i++){
				list2[i] = list1[i];
			}
			
			for(int i = 0;i <list2.length;i++){
				System.out.println(list2[i]);
			}
		}

}

数组的查询算法

数组的查找算法：for循环遍历和if判断

package list;
import java.util.*;
public class listSelect {
		public static void main(String[] args){
			Scanner in = new Scanner(System.in);
			System.out.print("请输入你要查询的用户：");
			String name = in.next();
			//定义存放所有用户的数组
			String allName[] ={"张帅","张三","李思","赵虎","张三","刘栋","李围城","刘冬","何柳","何六"} ;
			//声明一个布尔类型的变量作为标记
			boolean person = false;
			for(int i=0;i<allName.length;i++){
				if(name.equals(allName[i])){
					person = true;
					//break;
				}
			}
			if(person == true){
				System.out.println("找到了！！");
			}else{
				System.out.println("没有这个人！！");
			}
		}

}

//数组的搜索算法
package list;
import java.util.*;
public class arrayTest {
	public static void main(String[] arg){
		Scanner in = new Scanner(System.in);
		System.out.println("请输入你需要搜索的学生：");
		String name = in.next();
		String students[] = {"李跃","刘冬","张飞","贺飞"};
		boolean fla3g = false;
		for(int i = 0;i<students.length;i++){
			if(name.equals(students[i])){
				fla3g = true;
				break;
			}
		}
		if(fla3g == true){
			System.out.println("找到"+name+"啦");
		}
		else {
			System.out.println(name+"不存在这个系统中");
		}
	}
}

数组插入算法

在数组的最后插入一个元素，但是不能影响整个数组的顺序

//在数组int数组的最后一个元素替换替换掉，但是不能影响整个数组的顺序
package list;
import java.util.Scanner;
import java.util.Arrays;
public class arrayInsert {
	public static void main(String[] argStrings){
		Scanner in = new Scanner(System.in);
		System.out.println("请输入一个数：");
		int a = in.nextInt();
		int number[] = {31,3,4,5,6,7,4,3,2,23};
		Arrays.sort(number);
		//数组最后一个元素被用户输入的数替换掉
		number[number.length-1] = a;
		//为了不影响原来数组的顺序，需要遍历原数组，判断是否大于然后大于则替换
		for(int i=0;i<number.length;i++){
			if(number[i] > number[number.length-1]){
				int t;    //局部变量t
				t = number[i];
				number[i] = number[number.length-1];
				number[number.length-1] = t;
				}
		}
		for(int i=0;i < number.length; i=i+1){
			System.out.println(number[i]);
		}
	}
}

Python3实现：

#input()默认接收的是字符串类型str，这里需要转化为int
number = int(input("请输入一个数字："))
list1 = [2, 3, 22, 33, 1, 5, 66, 4, 0]
#升序排序
list1.sort()
#将元素反转
#list1.reverse()
#list1[len(list1)-1] = number
list1[-1] = number
for i in range(len(list1)):
    if list1[i] > list1[len(list1)-1]:
        t = list1[i]
        list1[i] = list1[len(list1)-1]
        list1[len(list1) - 1] = t
print(list1)

代码是不是少了很多！！

数组冒泡排序 两个循环实现的排序

原理：

前一个元素和后一个元素一遍遍对比；

里面的for循环，循环一次找出最大的数，在外面再加一个for循环，使里面的for循环执行数组长度次数,就实现冒泡排序

package list;

public class arraySort1 {
	public static void main(String[] args){
		int number[] = {22,3,44,5,6,1,53,8,9,2};
		for(int j = 0;j <number.length-1;j++){
			//里面的for循环，循环一次找出最大的数，在外面再加一个for循环，使里面的for循环执行数组长度次数,就实现冒泡排序
			for(int i=0; i<number.length-1;i++){
				if(number[i]<number[i+1]){
					int t;
					t = number[i];
					number[i] = number[i+1];
					number[i+1] = t;
				}
			}
		}
		for(int i=0 ; i<number.length;i++){
			System.out.println(number[i]);
		}
	}
}
再来看看看Python3写的： 

list1 = [2, 3, 22, 33, 1, 5, 66, 4, 0]
for j in range(len(list1) - 1):
    for i in range(len(list1) - 1):
        if list1[i] > list1[i + 1]:
            t = list1[i]
            list1[i] = list1[i + 1]
            list1[i + 1] = t

print(list1)
还是Python简单明了！！
数组选择排序

原理：打擂台的方式选择，只比较一次；选择一个是擂主，后一个数和擂主比较

//选择排序原理
package list;
import java.util.Random;
import java.util.Scanner;
import java.util.Arrays;
public class listSortSelect {
	public static void main(String[] args){
		int number[] = {22,3,44,5,6,2};
		//第一个for循环是擂主，执行到倒数第二个
		for(int i=0;i < number.length-1;i++){
			//第二个for循环是和擂主pk的人，初始值是擂主后一个 j = i+1，执行到最后一个数
			for(int j=i+1;j < number.length;j++){
				if(number[i]>number[j]){
					int t = number[i];
					number[i] = number[j];
					number[j] = t;
				}
			}
		}
		for(int i = 0;i < number.length;i++){
			System.out.println(number[i]);
		}
	}
}

二维数组

声明二维数组：两个[][]--------->有几个[]就是什么数组；

二维数组是指：数组中元素是数组，数组的数组

package list;

public class erWeilist {
	public static void main(String[] args){
		int a[][] = {{12,3},{3},{55,66,77,88}};
		System.out.println(a[2][3]);
	}
}

另外：Java中多为数组的声明和初始化，必须按照高维到低维进行！


oOo右右
关注
专栏目录
Java基础--数组练习2
07-25
Java基础之数组练习2
java中的数组int[]
热门推荐
Javapengyuyan的博客
12-04 3万+
数组 数组概念 数组是存储同一种数据类型多个元素的容器。 数组既可以存储基本数据类型，也可以存储引用数据类型。 数组的定义格式 格式1：数据类型[] 数组名; 格式2：数据类型 数组名[]; 注意：这两种定义做完了，数组中是没有元素值的 数组初始化的概述 Java中的数组必须先初始化,然后才能使用。 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。 动态初始化:初始化时只指定数组长度，由系统为数组分配初始值 格式：数据类型[] 数组名 = new 数据类型[数组长度]; 数组长度其实就
Java基础——数组
explorer363的博客
04-18 7047
本篇文章介绍了什么是数组，数组的使用，数组与方法之间的关系，以及通过几个数组联系加深对数组的理解
Java数组详解（超全）
ZJH
07-24 2万+
正确写法： 1.步骤角度:(以下int可以替换为char String double等等) ①一步写法：int [ ] ids = new int [ ] {1001,1002,1003}; ②两步写法：int [ ] ids ; ids = new int [ ] {1001,1002,1003} ; 2.状态角度 ①静态初始化：两个[ ]均为空 St...
--数组--
adminhl的博客
08-05 214
数组 1.什么是数组 数组是相同类型数据的有序集合。 2.数组的创建 //语法： dataType[] arrayRefVar;(推荐使用) 或者 dataType arrayRefVar[]; ​ int[] nums; //声明一个数组 ​ nums = new int[10]; //创建一个数组，里面可以存放10个int类型的数据 ​ // int[] nums = new int[10]; ​ nums[0] = 1; //...
Java学习资料-数组
最新发布
06-15
Java中的数组是编程中不可或缺的基础概念，主要用于存储一组相同类型的元素。数组的使用极大地提高了代码的效率和可读性，特别是在处理大量数据时。数组有三个核心特性：一致性（所有元素同类型）、有序性（通过下标...
Educoder题目：Java入门 - 数组基础答案解析.md
11-01
Educoder题目：Java入门 - 数组基础答案解析
Java基础--Java数组的认识（通透！！！）
07-23
Java基础--Java数组的认识（通透！！！） Java数组的认识是Java基础知识中的一部分，了解Java数组的概念、性质、写法、初始化、元素访问和应用是非常重要的。本节课程将带您深入了解Java数组的世界。 一、 简单...
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
JAVA基础之int[]数组逆序排序
qq_33479841的博客
08-13 8820
有一个int[]，数组内有一定数量的元素，将该数组内元素按逆序排序，解析所使用方案的优缺点。假定数组int[] arrs={5,1,6,3,4,9,22,65,77}。
JAVA数组介绍
weixin_59367169的博客
07-19 1788
1.1、数组概述1.2、什么是数组1.3数组的定义格式格式一数据类型[]变量名范例格式二数据类型变量名[]范例定义了一个int类型的数组，数组名是arr。
java数组
weixin_52923290的博客
01-10 502
java数组：定义、格式、初始化、遍历；二维数组
java数组int_Java数组（int为例）
weixin_30700095的博客
02-12 8018
Java数组(int为例)定义：相同数据类型的数据的组合,是一种引用类型，是一个对象，存在堆里。数组初始化：int[] scores1 = new int[]{72,90,59};//静态初始化：在声明并初始化数组与给数组相应的元素赋值操作同时进行。int scores2[] = new int[3];scores2[0] = 72;scores2[1] = 90;scores2[2] = 59;...
JAVA基础语言
2301_76545552的博客
03-03 3201
一、整数类型 整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正整数，也可以是负数。整型数据根据它所占内存大小的不同，可分为byte、short、int和long 4种类型。它们具有不同的取值范围。 1.int型 定义int变量有以下四种语法： int型是java整型值的默认数据类型。当多个尚未运行定义数据类型的整数做运算时，运算的结果将默认为int类型。例如，下面这行代码： 等同于如下代码： 2.byte型 byte型的定义方式与int相同。定义int型变量
Java-数组和集合简单使用
dibu3564的博客
09-10 316
数组和集合： 1.数组第一种定义方式 int[] counts = {1,2,3,4,5}; 2.数组第二种定义方式(先初始化，后赋值) int[] numbers = new int[3]; numbers[0] = 1; numbers[1] = 2; numbers[2] = 3; numbers[0] = 1000;//在索引范围以内可以更改 ...
java中int的基本概念
分享+记录
10-30 6571
java中int的一些基本概念
Java基础----数据类型
weixin_62811870的博客
05-17 724
以下代码皆在eclipse内进行操作 基本数据类型 1.整型 概念:就是存储整数的数据类型.整型数据类型根据占用的内存空间位数不同分为四种: byte(字节),short(短整型),int(整型),long(长整型) . 类型 占位 字节 取值范围 整数范围 byte字节类型 8位 1个字节 -2^7 ~ 2^7-1 -128 ~ 127 short短整型 16位 ...
Java----int[][] 二维数组排序
long_steve的博客
06-23 1356
是类中的一个静态方法，可以对数组进行排序，但是仅支持对一维数组进行排序，如果需要对二维数组进行排序，需要重写sort()方法中的比较器。1、方法1（1） 表示升序， 表示降序 （2）o1[0]表示第一个元素，以此类推，需要根据第几个元素排序，写入就好： 2、使用Lambda 表达式的方式对比较器进行简写。（JDK1.8+） 3、使用方法。.........
Java基础--数组练习2：互换元素案例与创建两个数组案例
Java基础--数组练习2 在Java中，数组是一种用来存储一组相同数据类型的数据的容器。它的特点包括数组是一个引用数据类型，数组内部可以存储基本类型或引用类型的元素。当我们创建数组时，需要指定数组的长度，并在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值