java从入门到入土第7天

已于 2024-05-08 11:27:40 修改
阅读量72 收藏
点赞数
分类专栏： java入门到入土 文章标签： java 开发语言 排序算法
于 2024-04-29 23:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_yin0/article/details/138328883
版权

Day07

import java.util.Scanner;
public class Work01{
	/**
		1.键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
	*/
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入1~9的数字：");
		int n = scan.nextInt();
	
		method(n);
	}
	
	public static void method(int n){
		if(n<1 || n>9){
			return;
		}
		for(int i = 1;i<=n;i++){
			for(int j = 1;j<=i;j++){
				System.out.print(j + "x" + i + "=" + (i*j) + "\t");
			}
			System.out.println();
		}
	}
	
}

public class Work02{
	/**
		2.素数也叫质数.是除了1和其本身,不能被其他正整数整除的正整数.
			例如：2,3,5,7,11,13,17,19,23.....
			a)写一个方法判断该数是否为素数（设计成一个方法）
			b)输出某个范围内的所有素数，比如100-200之间。
	*/
	public static void main(String[] args){
		
		for(int num = 100;num<=200;num++){
			if(isPrimeNumber(num)){
				System.out.println(num);
			}
		}
		
	}
	
	public static boolean isPrimeNumber(int num){
		for(int i = 2;i<num;i++){
			if(num % i == 0){
				return false;
			}
		}
		return true;
	}
}

public class Test01{
	/**
		知识点：数组的排序 -- 冒泡排序
		
		口诀：
			N个数字来排队
			两两相比小靠前
			外层循环N-1
			内层循环N-1-i
	*/
	public static void main(String[] args){
		
		int[] arr = {6,3,7,5,2,1};
		
		for(int i = 0;i<arr.length-1;i++){
			for(int j = 0;j<arr.length-1-i;j++){
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		for(int element : arr){
			System.out.println(element);
		}
		
	}
}

public class Test02{
	/**
		知识点：数组的查找 -- 线性查找
		
	*/
	public static void main(String[] args){
		
		int[] arr = {6,3,7,5,2,1};
		
		int num = 6;
		
		for(int i = 0;i<arr.length;i++){
			if(num == arr[i]){
				System.out.println("元素查找到了,下标为：" + i);
			}
		}
		
	}
}

import java.util.Arrays;
public class Test03{
	/**
		知识点：数组的查找 -- 二分法/二叉查找
		
		注意：二分法查找之前必须先排序！！！
		
	*/
	public static void main(String[] args){
		
		int[] arr = {6,3,7,5,2,1};
		
		//排序 -- 1,2,3,5,6,7
		Arrays.sort(arr);
		
		int num = 6;
		
		int start = 0;
		int end = arr.length-1;
		
		while(start <= end){
			
			int mid = (start+end)/2;
			
			if(num < arr[mid]){
				end = mid-1;
			}else if(num > arr[mid]){
				start = mid+1;
			}else{
				System.out.println("元素查找到了,下标为：" + mid);
				break;
			}
		}	
	}
}

public class Test04{
	/**
		知识点：数组的复制1 - 浅表赋值
		
		缺点：修改原数组，新数组中的数据也会发生改变
	*/
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"麻生希","椎名空","水菜丽"};
		
		//新数组
		String[] newArr = arr;
		
		//修改原数组
		arr[1] = "侯小康";
		
		//遍历新数组
		for(String element : newArr){
			System.out.println(element);
		}
		
	}
}

public class Test05{
	/**
		知识点：数组的复制2 - 深表赋值
	*/
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"麻生希","椎名空","水菜丽"};
		
		//新数组
		String[] newArr = new String[arr.length];
		
		//将原数组下标的元素赋值给新数组
		for(int i = 0;i<arr.length;i++){
			newArr[i] = arr[i];
		}
		
		//修改原数组
		arr[1] = "侯小康";
		
		//遍历新数组
		for(String element : newArr){
			System.out.println(element);
		}
		
	}
}

public class Test06{
	/**
		知识点：数组的扩容
	*/
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"麻生希","椎名空","水菜丽"};
		
		//计算新容量
		int oldCapacity = arr.length;//3
		int newCapacity = oldCapacity + (oldCapacity>>1);//4
		
		//新数组
		String[] newArr = new String[newCapacity];
		
		//将原数组下标的元素赋值给新数组
		for(int i = 0;i<arr.length;i++){
			newArr[i] = arr[i];
		}
		
		//将新数组的地址赋值给原数组
		arr = newArr;
		
		//遍历原数组
		for(String element : arr){
			System.out.println(element);
		}
	}
}

public class Test07{
	/**
		知识点：数组的删除1
		缺点：数组作为容器，是存储数据的，这样的删除会让容器越变越小
		
		作业：画内存图
	*/
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"麻生希","椎名空","水菜丽","樱井步"};
		
		//新数组
		String[] newArr = new String[arr.length-1];//3 - [null,null,null]
		
		//将除了"椎名空"的元素赋值给新数组 -- ["麻生希","水菜丽","樱井步"]
		int index = 0;
		for(String element : arr){
			if(!element.equals("椎名空")){
				newArr[index++] = element;
			}
		}
		
		//将新数组的地址赋值给原数组
		arr = newArr;
		
		//遍历原数组
		for(String element : arr){
			System.out.println(element);
		}
		
	}
}

public class Test08{
	/**
		知识点：数组的删除2
		
		作业：画内存图
	*/
	public static void main(String[] args){
		
		//原数组
		String[] arr = {"麻生希","椎名空","水菜丽","樱井步"};
		
		//将删除元素后一位的数据全部都往前移 -- "麻生希","水菜丽","樱井步","樱井步"
		for(int i = 1;i<arr.length-1;i++){
			arr[i] = arr[i+1];
		}
		
		//将最后一位数据赋值为null
		arr[arr.length-1] = null;
		
		//遍历原数组
		for(String element : arr){
			System.out.println(element);
		}
		
	}
}

public class Test09{
	/**
		知识点：数组作为方法的参数和返回值
		
		需求：设计一个方法，传入int类型的数组，返回最大值和最小值
	*/
	public static void main(String[] args){
		
		int[] arr = {6,43,53,56,467,41,35};
		
		int[] newArr = getMaxAndMin(arr);
		System.out.println("最大值为：" + newArr[0]);
		System.out.println("最小值为：" + newArr[1]);
	}
	
	public static int[] getMaxAndMin(int[] arr){
		
		int max = arr[0];
		int min = arr[0];
		
		for(int i = 1;i<arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
			if(min > arr[i]){
				min = arr[i];
			}
		}
		
		int[] maxAndMin = {max,min};
		return maxAndMin;
	}
	
}

public class Test10{
	/**
		知识点：可变参数
		
		
		需求：设计一个方法，传入n个int类型的值，返回最大值
	*/
	public static void main(String[] args){
		
		int max = getMax(1,2,3,4,5,6,7);//将实参作为数组的元素传入
		System.out.println(max);
	}
	
	//int... arr -- 可变参数，实际上就是数组
	public static int getMax(int... arr){
		if(arr.length == 0){//意味着实参没有传任何数据
			return -1;
		}
		int max = arr[0];
		for(int i = 1;i<arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
		}
		return max;
	}
	
	//注意：可变参数后不能接其他参数
	public static void method(int i,String... ss){
		
	}
}

import java.util.Arrays;
public class Test11{
	/**
		知识点：Arrays工具类
		理解：Arrays是Java给我们提供的专门用于操作数组的工具类
		
		概念：
			工具类 -- 该类中的方法都是静态的，直接使用类名调用
			API ----- Java提供类的说明书
	*/
	public static void main(String[] args){
			
		int[] arr = {5,72,9,4,21,1,6,3,81};	
		
		//排序 - 1,3,4,5,6,9,21,72,81
		Arrays.sort(arr);
		
		//查找
		//返回值规则：搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 
		//返回值规则：如果元素包含在数组中，返回下标;否则，(-(插入点) - 1) 
		int index = Arrays.binarySearch(arr,30);
		System.out.println("查找到元素的下标为：" + index);
		
		//拷贝数组 - [1, 3, 4, 5, 6, 9, 21, 72, 81, 0, 0, 0, 0, 0, 0]
		int[] newArr1 = Arrays.copyOf(arr,15);
		
		//拷贝数组区间 - [4, 5, 6, 9, 21, 72, 81, 0, 0]
		int[] newArr2 = Arrays.copyOfRange(newArr1,2,11);//(目标数组，开始下标-包含，结束下标-排他)
		
		//替换所有元素 - [888, 888, 888, 888, 888, 888, 888, 888, 888]
		Arrays.fill(newArr2,888);
		
		//替换区间元素
		Arrays.fill(newArr2,2,4,666);//(目标数组，开始下标-包含，结束下标-排他，替换元素)
	
		//将数组转换为字符串
		String str = Arrays.toString(newArr2);
		System.out.println(str);
	}
}

public class Test12{
	/**
		知识点：二维数组
		理解：二维数组包含了多个一维数组
		数组的声明：
			数据类型[][] 数组名;
			数据类型 数组名[][];
	*/
	public static void main(String[] args){
		
		//静态初始化1
		//String[][] names = new String[][]{{"麻生希","椎名空","水菜丽"},{"三上悠亚","爱田奈奈","古川伊织","水野朝阳"}};
		
		//静态初始化2
		//String[][] names;
		//names = new String[][]{{"麻生希","椎名空","水菜丽"},{"三上悠亚","爱田奈奈","古川伊织","水野朝阳"}};
		
		//静态初始化3
		String[][] names = {{"麻生希","椎名空","水菜丽"},{"三上悠亚","爱田奈奈","古川伊织","水野朝阳"}};
		
		//设置指定下标上的元素
		names[0][1] = "侯小康";
		
		//获取指定下标上的元素
		String str = names[0][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的长度：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的长度：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的长度：" + names[1].length);//4
		
		System.out.println("------------------------------------");
		
		//遍历思路：循环遍历出一维数组，再循环遍历一维数组的元素
		
		//遍历数组 -- for循环
		for(int i = 0;i<names.length;i++){
			for(int j = 0;j<names[i].length;j++){
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("------------------------------------");
		
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	
	}
}

public class Test13{
	/**
		知识点：二维数组
		理解：二维数组包含了多个一维数组
		数组的声明：
			数据类型[][] 数组名;
			数据类型 数组名[][];
	*/
	public static void main(String[] args){
		
		//动态初始化1
		//String[][] names = new String[2][3];//2表示2个一维数组，3表示每个一维数组有3个元素
		
		//动态初始化2
		String[][] names;
		names = new String[2][3];//2表示2个一维数组，3表示每个一维数组有3个元素
		
		//设置指定下标上的元素
		names[0][1] = "侯小康";
		
		//获取指定下标上的元素
		String str = names[0][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的长度：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的长度：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的长度：" + names[1].length);//4
		
		System.out.println("------------------------------------");
		
		//遍历思路：循环遍历出一维数组，再循环遍历一维数组的元素
		
		//遍历数组 -- for循环
		for(int i = 0;i<names.length;i++){
			for(int j = 0;j<names[i].length;j++){
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("------------------------------------");
		
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	
	}
}

public class Test14{
	/**
		知识点：二维数组
		
		需求：使用动态初始化声明二维数组，二维数组中有两个一维数组
			  第一个一维数组有3个元素
			  第二个一维数组有4个元素
	*/
	public static void main(String[] args){
		
		String[][] names = new String[2][];
		
		String[] s1 = {"aaa","bbb","ccc"};
		String[] s2 = {"ddd","eee","fff"};
		
		names[0] = s1;
		names[1] = s2;
		
		for(String[] ss:names){
			for(String element:ss){
				System.out.println(element);
			}
		}
	}
} 

1.一维数组的排序 -- 冒泡排序 -- 了解

2.一维数组的查找 -- 线性查找、二分法查找 -- 了解

3.数组的复制、扩容、删除 --- 重要！！！！

4.数组做为方法的参数和返回值

5.可变参数

6.Arrays工具类

7.二维数组

作业：
	1.知识点的梳理文档
	2.代码编写3遍
	3.画内存图
	4.课后作业
	5.复习：方法的重载和递归
	5.预习：面向对象
奇怪的魔法猫娘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java学习路线从入门到入土
qq_45077173的博客
09-20 1万+
Java学习路线从入门到入土 简介 一门永不过时的编程语言——Java 编程开发。Java编程语言占比：据官方数据统计，在全球编程语言工程师的数量上，Java编程语言以900万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程，因此其程序员的数量最多。而在以Java编程为核心的开发领域中，javaEE程序员的需求量10年来一直居于首位！Java工程师人才缺口：根据IDC的统计数字：就2017年来说，我国Java人才的缺口已达42.5万，并且以每年20%左右 的速度增长。在未来5年内,合格软件人才
java从入门到入土第2天
xiao_yin0的博客
04-23 826
理解：IDE（编码环境），就是写代码的工具升级：记事本 -> nodepad++ -> eclipse -> IDEAIDE - 编码环境编码问题关键字及关键字变量及注意事项基本数据类型（byte、short、int、long、float、double、char、boolean）基本数据类型的转型。
java从入门到入土第4天
xiao_yin0的博客
04-25 372
6.预习：while、do-while、特殊的流程控制语句。1.转义字符：具有特殊意义的字符本身。数字字面量、字面值常量、final。5.复习：运算符的面试题、特殊点。3.Java执行语句的分类。1.知识点的梳理文档s。5.switch分支。
java从入门到入土第5天
xiao_yin0的博客
04-26 702
6.提升作业：分别使用for循环、while循环实现。5.预习：方法、数组、面向对象。1.嵌套for循环 – 重要。3.do-while循环。5.特殊的流程控制语句。4.复习：本周所有内容。6.万年历 – 重要。1.知识点的梳理文档。
java从入门到入土第一卷
11-08
没事复习一遍
Java 学习路线思维导图-从入门到入土
11-19
这份资源是xmind版本，自己电脑需要下载个xmind软件才能打开。
Java从入门到入土之面向对象之三大特性之多态的思维导图
12-18
多态的思维导图
java入门到入土.md
02-20
java入门到入土.md
JAVA教程集合汇总-从入门到入土【汇总多年-史上最详细】呕心沥血整理
02-16
Java教程集合汇总，这是一份全面且深入的学习资源，涵盖了从初学者到高级开发者所需的知识点，旨在帮助学习者从入门到精通Java编程语言。这份呕心沥血整理的资料库，不仅包含了基础理论，还涵盖了实践应用，是Java...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1177
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 475
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 228
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1935
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1326
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 993
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
最新发布
Sakurapaid的博客
07-25 230
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 846
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 711
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
java学习怎么从入门到入土
03-31
作为一个 AI，我不能协助您在学习过程中“入土”，因为我的宗旨是帮助人们更好地学习和成长。以下是一些建议，可以帮助您更好地学习 Java。 1. 学习基础：首先，您需要了解 Java 的基础知识，例如变量、数据类型、控制结构、循环等。可以通过阅读书籍或在线教程来学习这些基础知识。 2. 练习编程：学习编程最好的方法是通过编写代码来进行实践。可以使用练习题或者参与开源项目来锻炼编程能力。 3. 学习面向对象编程：Java 是一种面向对象编程语言，因此学习面向对象编程是非常重要的。学习类、对象、继承、封装、多态等概念，并且在实践中应用这些概念。 4. 学习 Java 库和框架：Java 有许多库和框架，可以帮助您更高效地编写代码。例如，学习 Java 的标准库、Spring 框架等。 5. 继续深入学习：Java 是一种非常广泛应用的编程语言，因此需要不断地深入学习并跟上技术的发展。可以学习 Java 8 新特性、Java EE、Android 开发等。 总之，学习 Java 需要不断地努力和实践，并且需要持续学习并跟上技术的发展。祝您学习愉快！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值