Java基础5--数组

最新推荐文章于 2021-03-11 13:32:08 发布

oOo右右

最新推荐文章于 2021-03-11 13:32:08 发布

阅读量422

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/JOJOY_tester/article/details/77278929

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

数组

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右右

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础5--数组

数组jvm Java虚拟机Java的虚拟内存4栈区存放函数的参数值，局部变量的值。存放Java基础类型：int String double char等超过这个变量的作用域时就会被系统自动释放在jvm内存中的资源。超过变量作用域指：局部变量只能在某部分使用，如循环、判断内定义的变量，超过这个作用域变量就会失效。在哪个大括号声明的作用域就是这个大括号的范围缺点：存在栈区
复制链接

扫一扫