稳稳当当学java之数组(7)

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量191 收藏
点赞数 2
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42405054/article/details/106467944
版权

第九章 数组

1.作业回顾

1，定义一个方法，功能是打印m行n列的指定符号的矩形，在主方法中调用此方法。

2，定义一个方法，功能是计算 长为x，宽为y的矩形的面积，在主方法中调用此方法，在主方法中打印结果。

3，定义一个方法，实现找出三个数的 最大值，并在主方法中调用此方法，在主方法中打印结果。

public class Day091 {

	//1, 定义一个方法，功能是打印m行n列的指定符号的矩形，在主方法中调用此方法。
	public static void Print_rectangular(int m, int n, String str) {
		for (int i = 1; i <= m; i++) {
			for (int j = 1; j <= n; j++) {
				System.out.print(str);
			}
			System.out.println();
		}
	}
	
	//2, 定义一个方法，功能是计算长为x，宽为y的矩形的面积，在主方法中调用此方法，在主方法中打印结果。
	public static int Calculate_area(int x ,int y) {
		return x * y;
	}
	
	//3, 定义一个方法，实现找出三个数的最大值，并在主方法中调用此方法，在主方法中打印结果。
	public static int find_max_of_vulue(int a, int b, int c) {
		return a > b ? (a > c ? a : c) : (b > c ? b : c);
	}
	
//	public static int find_max_of_vulue(int a, int b, int c) {
//		return a > b ? Math.max(a, c) : Math.max(b, c);
//	}
	
	public static void main(String[] args) {
		Print_rectangular(4, 4, ".");
		int result = Calculate_area(4, 2);
		System.out.println(result);
		System.out.println(find_max_of_vulue(3, 2, 5));	
	}
}

2.数组的概念

什么是数组？

数组是一个容器，它可以保存一定数量的同一类型的数据。当数组创建完成后，它的长度就固定下来了。

数组是一块连续的存储空间。

int数组，内部可以存放int数据，如果数组的第一个元素地址：0000，0004，0008，0012

在这里插入图片描述

3.创建，初始化，和访问数组

public class Day092 {

	public static void main(String[] args) {
		//声明一个数组变量
		int[] arr;
		//创建一个可以存放10个int的数组
		arr = new int[10];
		//给数组的第一个元素赋值为10
		arr[0] = 10;
		//给数组的第二个元素赋值为20
		arr[1] = 20;
		arr[2] = 30;
		arr[3] = 40;
		arr[4] = 50;
		arr[5] = 60;
		arr[6] = 70;
		arr[7] = 80;
		arr[8] = 90;
		//长度为10的数组最后一个元素的下标为9
		arr[9] = 100;
		
		//将数组的第一个元素的值赋值给变量a
		int a = arr[0];
		System.out.println(a);
		//输出数组的最后一个元素
		System.out.println(arr[9]);
	}
}

在这里插入图片描述

public class Day093 {

	public static void main(String[] args) {
		//数组是引用类型的
		//声明了一个数组变量
		//变量的类型是int[]，int是数组中元素的类型
		//这个声明并不会真正的创建数组，它只是声明了一个可以引用的int类型数组的变量
		int[] arr; //这个变量现在没有存放任何数据
		
		//new int[10];这个语句，new操作符创建一个可以容纳10个int的数据
		//将数组的引用（地址）赋值给arr，这样变量arr就引用了这个数组
		//数组相当于空调，数组变量arr相当于空调的遥控器，通过遥控器可以操控空调
		arr = new int[10];
		
		//将数组变量arr的值（它所引用的数组的地址）赋值给数组变量arr1
		//现在arr和arr1引用同一个数组
		int[] arr1 = arr;
		
		//将10赋值给arr所引用的的数组
		arr[0] =10;
		//取出arr1引用的数组的第一个元素的值
		System.out.println(arr1[0]);
	}
}

在这里插入图片描述

public class Day094 {

	public static void main(String[] args) {
		//可以声明其他类型的数组
		byte[] arr1 = new byte[5];
		long[] arr2 = new long[10];
		
		String[] arr3 = new String[12];
		
		//str是对象变量，它引用了字符串对象abc
		//将字符串对象abc的地址赋值给对象变量str
		String str = "abc";	
	}
}

public class Day095 {

	public static void main(String[] args) {
		//可以使用更简洁的方式来创建和初始化数组
		//{10, 20, 30, 40}创建了一个长度为4的int数组，元素分别为10, 20, 30, 40
		int[] arr = {10, 20, 30, 40};
		
		System.out.println(arr[1]); //取第二个元素//20
		
		//获取数组的长度
		System.out.println(arr.length); //4
		
		//获取数组最后一个元素
		System.out.println(arr[arr.length - 1]); //40	
	}
}

public class Day096 {

	public static void main(String[] args) {
		//动态创建数组
		int n = 10;
		int[] arr = new int[10];
		
		//数组的默认值
		//创建一个数字数组（byte，short，int，long）所有的元素都初始化为0
		//float和double是0.0
		//boolean类型的初始化为false
		//数组中元素如果是引用类型，那么初始化为null，表示此元素不引用任何对象
		int[] arr1 = new int[5];
		//遍历数组中的所有元素
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i]);
		}//00000
		
		System.out.println();
		
		String[] arr2 = new String[10];
		for (int i = 0; i < arr2.length; i++) {
			System.out.print(arr2[i]);
		}//nullnullnullnullnullnullnullnullnullnull
	}
}

public class Day097 {

	public static void main(String[] args) {
		int[] arr = {10, 20, 30, 40};
		//数组下标越界异常ArrayIndexOutOfBoundsException
		System.out.println(arr[4]); 	
	}
}

4.遍历数组

public class Day098 {

	public static void main(String[] args) {
		int[] arr = {100, 200, 300, 400, 500};
		//使用for循环遍历数组中的所有元素
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}//100200300400500
		
		System.out.println();
		
		//使用foreach来遍历数组
		//每次执行迭代时，将arr中对应的元素取出，赋值给i
		//i代表当前元素，因为在执行迭代时会计数
		//int是元素的类型
		for(int i : arr) {
			System.out.print(i);
		}//100200300400500
		
		System.out.println();
		
		String[] arr1 = {"a", "b", "c"};
		//String是元素的类型
		for(String str : arr1) {
			System.out.print(str);
		}//abc
		
		System.out.println();
		
		//增强的for循环不能修改元素的值
		for (int i : arr) {
			i = 1;
		}
		
		for (int i : arr) {
			System.out.print(i);
		}//100200300400500
	}
}

5.基本数据类型和引用数据类型的区别

5.1赋值

public class Day099 {
	public static void main(String[] args) {
		int a = 9;
		int b = a; //将a的值拷贝给b
		a = 8;
		System.out.println(b); //9
		
		int[] arr1 = {100, 200, 300};
		int[] arr2 = arr1; //arr1和arr2引用同一个数组
		arr1[0] = 101;
		System.out.println(arr2[0]); //101	
	}
}

5.2传参

public class Day0910 {
	
	public static void f(int n) {
		n = 9;
	}
	
	public static void main(String[] args) {
		//传参和赋值是一样的
		int a = 10;
		f(a); //拷贝实际参数a的值到形式参数n
		System.out.println(a); //10
		
		int n = 10;
		f(n); //拷贝实际参数n的值到形式参数n
		System.out.println(n); //10，这里的n和f中的n不是一个变量
	}	
}

public class Day0911 {

	public static void f(int[] n) {
		n[0] = 9;
	}
	public static void main(String[] args) {
		//传参和赋值是一样的
		int [] a = {100, 200, 300};
		f(a); //拷贝实际参数a的值（数组的地址）到形式参数n，现在a和n引用同一个数组
		System.out.println(a[0]); //9
	}
}

5.3基本类型和引用类型，不管是赋值还是传参，都是值拷贝。

public class Day0912 {
	public static void main(String[] args) {
		//基本类型的相等性比较
		int a = 10;
		int b = 10;
		System.out.println(a == b); //true，比较的是值
		
		//引用类型的相等性比较
		int[] arr1 = {1, 2, 3};
		int[] arr2 = {1, 2, 3};
		//变量arr1和变量arr2存放的是不同数组的地址
		System.out.println(arr1 == arr2); //false
		
		int[] arr3 = arr1;
		System.out.println(arr1 == arr3); //true
	}
}

6.使用Arrays类

java.utils.Arrays类中包含了用来操作数组的方法。

6.1相等性比较

import java.util.Arrays;

public class Day0913 {

	public static void main(String[] args) {
		int[] arr1 = {1, 2, 3};
		int[] arr2 = {1, 2, 3};
		System.out.println(arr1 == arr2); //false
		
		//比较数组中每一个元素的值
		System.out.println(Arrays.equals(arr1, arr2)); //true
	}
}

6.2数据填充

import java.util.Arrays;

public class Day0914 {
	public static void main(String[] args) {
		int[] arr = new int[3];
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}//000
		
		System.out.println();
		
		//将数组的每一个元素都填充为2
		Arrays.fill(arr, 2);
		
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}//222	
	}
}

6.3排序

import java.util.Arrays;

public class Day0915 {

	public static void main(String[] args) {
		int[] arr = {20, 4, 16, 80};
		//从小到大排序
		Arrays.sort(arr);
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

6.4查找

import java.util.Arrays;

public class Day0916 {
	public static void main(String[] args) {
		int[] arr = {20, 4, 16, 80};
		//查找元素4的下标
		System.out.println(Arrays.binarySearch(arr, 4)); //1
	}
}

6.5格式化输出

import java.util.Arrays;

public class Day0917 {

	public static void main(String[] args) {
		int[] arr = {20, 4, 16, 80};
		System.out.println(arr); //[I@4361bd48
		
		//格式化输出
		System.out.println(Arrays.toString(arr)); //[20, 4, 16, 80]
	}
}

6.6拷贝

public class Day0918 {

	public static void main(String[] args) {
		int[] arr1 = {20, 4, 16, 80};
		//创建一个新的数组，将原数组中的元素依次赋值到新数组，返回新数组的地址
		int[] arr2 = Arrays.copyOf(arr1, arr1.length);
		System.out.println(Arrays.toString(arr2)); //[20, 4, 16, 80]
		System.out.println(arr1 == arr2); //false，arr1和arr2没有任何关联
		
		//拷贝下标1到下标2之间的元素，包含开头不包含结束
		int[] arr3 = Arrays.copyOfRange(arr1, 1, 2);
		System.out.println(Arrays.toString(arr3)); //[4]	
	}
}

7练习

1，找出数组中元素的最大值 。

2，找出数组中元素的最大值和下标 。

3，数组反转[12345]—[54321]。

十年之伴
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
js横竖倾斜遍历二维数组
jsjs_js的博客
11-06 909
js遍历任意形状二维数组，我完全是找规律用大量循环完成遍历，这里的二维数组指完整矩形，不包含内部子数组长度不一致情况。 定义二维数组 ,数组中子数组长度设为x，外面大数组长度为y let arr = [ [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5,
稳稳当当学java之Collection和List(16)
weixin_42405054的博客
08-27 159
第十八章 Collection和List 1.作业回顾 //写一个TestException类，在main方法中接受两个命令行参数， //将他们转换成整数，并用第二个数除以第一个数，打印结果。 //测试一下情况，某个参数不是数字(异常1)，第二个参数为0.(异常2) public class Day17HomeWork { public static void main(String[] args) { System.out.println(args[0]);//1 System.out.prin
横向遍历为什么比纵向遍历快
qq_41865296的博客
04-04 585
平时看到有关CPU缓存行的时候 都会看到如下代码和问题： 横向遍历和纵向遍历哪种速度更快？ int[][] array = new int[64 * 1024][1024]; //横向遍历 80ms for(int i = 0; i < 64 * 1024; i ++) for(int j = 0; j < 1024; j ++) array[i][j] ++; // 纵向遍历 2100+ms for(int i = 0; i < 1024; i ++)
为什么二维数组横向遍历比纵向遍历快？
scarificed的博客
09-30 996
为什么二维数组横向遍历比纵向遍历快？
二维数组横向和纵向遍历的巨大差距：缺页问题
qq_44768363的博客
09-10 1629
缺页问题 缺页是引入了虚拟内存后的一个概念。操作系统启动后，在内存中维护着一个虚拟地址表，进程需要的虚拟地址在虚拟地址表中记录。一个程序被加载运行时，只是加载了很少的一部分到内存，另外一部分在需要时再从磁盘载入。被加载到内存的部分标识为“驻留”，而未被加载到内存的部分标为“未驻留”。操作系统根据需要读取虚拟地址表，如果读到虚拟地址表中记录的地址被标为“未驻入”，表示这部分地址记录的程序代码未被加载到内存，需要从磁盘读入，则这种情况就表示"缺页"。这个时候，操作系统触发一个“缺页”的硬件陷井，系统从磁盘换入这
稳稳当当学java之工具类(14)
weixin_42405054的博客
08-21 230
第十六章 工具类 1.作业回顾 //1，创建一个类Student，属性int id，String name，char gender，int age， //重写toString方法，重写hashCode和equals方法。 class Student { private int id; private String name; private char gender; private int age; public int getId() { return id; } public vo
稳稳当当学java之枚举和异常(15)
weixin_42405054的博客
08-23 223
第十七章 枚举和异常 1.作业回顾 //1，写一个方法判断字符串是否对称。对称的字符串。"abcdefgfedcba" public class Day16HomeWork { public static boolean f1(String str) { char[] arrs = str.toCharArray(); for (int i = 0; i < arrs.length / 2; i++) { if(arrs[i] != arrs[arrs.length - 1 - i
稳稳当当学java之面向对象编程(8)
weixin_42405054的博客
06-02 120
第十章 面向对象编程 1.作业回顾 1，找出数组中元素的最大值 。 public class Day101 { public static int max(int[] arr) { int result = Integer.MIN_VALUE; //-2147483648 for (int i = 0; i < arr.length; i++) { if(result < arr[i]) { result = arr[i]; } } return res
稳稳当当学java之文件和IO一(18)
weixin_42405054的博客
09-01 175
第二十章 文件和IO一 1.作业回顾 1，编写程序，在main方法中接受5个整数，创建TreeSet类型的集合，将5个整数添加到集合中，使用foreach遍历该集合。提供一个比较器，然后对于集合中的整数进行从大到小的顺序进行排序。然后使用Iterator进行迭代。 import java.util.Comparator; import java.util.Scanner; import java.util.TreeSet; public class Day19HomeWork { public stat
稳稳当当学java之继承(10)
06-05
本人的笔记，关于java基础中继承的内容 包括 1.作业回顾 2.成员变量的初始值 3.对象初始化 4.继承 5.子类对象的实例化过程 6.继承的规则一 7.练习
稳稳当当学java之方法(6).md
05-29
本人的笔记，关于Java基础中方法的内容。 包括 1.作业回顾 2.方法的定义 3.向方法传递参数 4.方法返回值 5.方法重载 6.变量的作用域 7.使用类常量和类方法 8.练习
稳稳当当学java之循环(5).md
05-29
本人的笔记，关于Java基础中循环的内容 包括 1.作业回顾 2.while 循环 3.do while 循环 4.for 循环 5.break语句 6.continue 语句 7.练习
Java-Lambda
最新发布
lizhiwei21的博客
07-21 173
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 492
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1141
JVM-垃圾回收与内存分配
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1169
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1065
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十年之伴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值