将四个整数进行从小到大的顺序排列 java_07_Java基础语法_第7天（练习）_讲义(练习加强+在eclipse中实现)...
第7天 Java基础语法
今日内容介绍
循环练习
数组方法练习
第1章 循环练习
1.1 编写程序求 1+3+5+7+……+99 的和值。
题目分析：
通过观察发现，本题目要实现的奇数(范围1-100之间)的累加和。
为了记录累加和的值，我们需要定义一个存储累加和的变量
我们要获取到1-100范围内的数
判断当前数是否为奇数，是奇数，完成累加和操作
累加完毕后，最终显示下累加和的值
解题步骤：
定义一个用来记录累加和的变量
使用for循环语句，完成1-100之间每个数的获取
使用if条件语句，判断当前数是否是奇数，是奇数，进行累加和操作
使用输出语句，打印累加和变量的值
/*
* 1.1编写程序求 1+3+5+7+……+99 的和值
* 实现步骤：
* 1.定义一个用来记录累加和的变量sum
* 2.使用for循环,完成1-100之间每个奇数的获取
* 采用for(int i = 1; i < 100; i += 2)
* 3.在for循环中,与sum进行累加,求和
* 4.使用输出语句,打印累加和变量的值sum
*/
public class LoopTest {
public static void main(String[] args) {
//1.定义一个用来记录累加和的变量sum
int sum = 0;
//2.使用for循环,完成1-100之间每个奇数的获取
for (int i = 1; i < 100; i += 2) {
//3.在for循环中,与sum进行累加,求和
sum += i;
}
//4.使用输出语句,打印累加和变量的值sum
System.out.println("1-100之间的奇数累加和:" + sum);
}
}
1.2 输出所有的水仙花数，所谓水仙花数是指一个数3位数，其每位数字立方和等于其本身，如153 = 111 + 333 + 555
题目分析：
通过观察发现，本题目要实现打印符合要求的数字(即水仙花数)。
明确什么样的数就是水仙花数。水仙花数是指一个3位数(100-999之间)，其每位数字立方之和等于该3位数本身。如153 = 111 + 333 + 555，
即 3位数本身 = 百位数立方 + 十位数立方 + 个位数立方;
获取水仙花范围内的所有3位数(100-999之间的每个3位数)
判断该3位数是否满足水仙花数，满足，打印该3位数
解题步骤：
使用for循环，得到100-999之间的每个3位数
获取3位数中百位数字、十位数字、个位数字
使用if条件语句，判断该3位数是否满足水仙花数，满足，使用输出语句，打印该3位数
/*
* 1.2输出所有的水仙花数，所谓水仙花数是指一个数3位数，其每位数字立方和等于其本身，
* 如153 = 1*1*1 + 3*3*3 + 5*5*5
* 实现步骤：
* 1.定义变量存储 三个数位的整数int
* 2.利用循环,循环中的变量,从100变化到999
* 3.在循环中得到的三位数,拆解成三个独立的数位
* 4.将三个数位的各自立方求和计算,求和后的数,用if条件语句
* 与她自己进行匹配,符合就是水仙花数,否则继续循环遍历
* 5.当找到水仙花数,用输出打印该水仙花数
*/
public class LoopTest1 {
public static void main(String[] args) {
//1.定义变量存储 三个数位的整数int
int bai = 0;
int shi = 0;
int ge = 0;
//2.利用循环,循环中的变量,从100变化到999
for (int i = 100; i <= 999; i++) {
//3.在循环中得到的三位数,拆解成三个独立的数位
bai = i / 100;
shi = i / 10 % 10;
ge = i % 10;
//4.将三个数位的各自立方求和计算,求和后的数,用if条件语句
// 与她自己进行匹配,符合就是水仙花数,否则继续循环遍历
if(bai * bai * bai + shi * shi * shi + ge * ge * ge == i){
//5.当找到水仙花数,用输出打印该水仙花数
System.out.println("水仙花数:" + i);
}
}
}
}
1.3 ASCII编码表
American Standard Code for Information Interchange，美国标准信息交换代码.
数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122，字母A-Z对应ASCII编码十进制为65-90
/*
* 1.3 char类型存储
* 数字0-9对应ASCII编码十进制为48-57,
* 字母a-z对应ASCII编码十进制为97-122，
* 字母A-Z对应ASCII编码十进制为65-90
* a.取值范围
* short:占两个字节,是有符号数据,取值范围-2^15 - 2^15 (-32767-32767)
*char：占两个字节,是无符号数据,取值范围0-2^16(0-65536)
* b.类型转换
* char类型的数据参加运算时,需要转换成int数据类型
* c.案例代码
* ASCII编码表演示
* 字符JAVA 数据类型,char
* 整数JAVA 数据类型,int
*
* int类型 和char数据类型转换
* char两个字节,int四个字节
*
* char转成int数据类型的时候,类型自动提升,char数据类型,会查询编码表,得到整数
* int转成char类型的时候,需要强制类型转换,会查询编码表
*
* char存储汉字,查询Unicode编码表
*
* char可以和int计算,提升为int类型,内存中两个字节
*
*/
public class LoopTest2 {
public static void main(String[] args) {
char c = 'a';
int i = c + 1;
System.out.println(i);
int j = 90;
char h = (char) j;
System.out.println(h);
System.out.println((char)6);
char k = '你';
System.out.println(k);
//char m = -1;
}
}
1.4 利用for循环打印ABCDEFG…XYZ，26个大写字母与26个小写字母
题目分析：
通过观察发现，本题目要实现打印26个大写字母、26个小写字母
一共26个大小写字母，那么，可以考虑循环26次。在每次循环中，完成指定字母的大小写打印
找出ABCDEFG…XYZ这些字母之间的变化规律
通过ASCII表发现，后面的字母比它前面的字母，ASCII值大1
下一个字母 = 上一个字母 + 1
如： A B C D
65 66 67 68
在每次循环中打印上一个字母大小写，并指定下一个字母
解题步骤：
定义初始化大写变量，值为’A’； 初始化小写变量，值为’a’
使用for循环，进行26次循环
在每次循环中，打印大写字母、小写字母。
每次打印完成后，更新大写字母值、小写字母值
/*
* 1.4利用for循环打印ABCDEFG...XYZ，26个大写字母与26个小写字母
* 实现步骤：
* 1.定义初始化大写变量,值为'A';初始化小写变量,值为'a'
* 2.使用for循环,进行26次循环
* 3.在每次循环的过程中,打印大写字母和小写字母(与此同时,更新大写字母,小写字母)
*/
public class LoopTest3 {
public static void main(String[] args) {
//1.定义初始化大写变量,值为'A';初始化小写变量,值为'a'
char da = 'A';
char xiao = 'a';
//2.使用for循环,进行26次循环
for (int i = 0; i < 26; i++) {
//3.在每次循环的过程中,打印大写字母和小写字母(与此同时,更新大写字母,小写字母)
System.out.println("大写字母:" + da + " 小写字母:" + xiao);
da++;
xiao++;
}
}
}
1.5 利用for循环打印 9*9 表?
如：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
import java.util.Scanner;
/*
* 1.5利用for循环打印 9*9 表?
* 实现步骤：
* 1.定义一个外层for循环,初始值从1开始,循环9次,用来控制打印的行数
* 2.在外层for循环内部,定义一个for循环,
* 初始值从1开始,循环次数与当前行数相等,用来完成每行打印指定次数的乘法公式
* 3.在内层for循环中,完成每行指定次数的乘法公式打印
* 4.在外层for循环中,当每行指定次数的乘法公式打印完毕后,通过System.out.println();切换到下一行
* 这样,再次打印乘法公式时,就在下一行输出打印了
*/
public class LoopTest4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//打印n * n乘法表
System.out.println("请输入你想打印乘法表的维数:");
int index = sc.nextInt();
System.out.println("如下打印:" + index + " * " + index + " 乘法表");
print99(index);
}
public static void print99(int index){
//1.定义一个外层for循环,初始值从1开始,循环index次,用来控制打印的行数
for (int i = 1; i <= index; i++) {
//2.在外层for循环内部,定义一个for循环
for (int j = 1; j <= i; j++) {
//3.在内层for循环中,完成每行指定次数的乘法公式打印
System.out.print(j + " * " + i + " = " + i * j + "\t");
}
//4.在外层for循环中,当每行指定次数的乘法公式打印完毕后,通过System.out.println();
System.out.println();
}
}
}
第2章 数组方法练习
2.1 定义打印数组元素方法,按照给定的格式打印[11, 33, 44, 22, 55]
题目分析：
通过观察发现，本题目要实现按照指定格式，打印数组元素操作
通过循环，我们可以完成数组中元素的获取，数组名[索引]
观察发现，每个数组元素之间加入了一个逗号”,”进行分隔；并且，整个数组的前后有一对中括号”[]”包裹数组所有元素。
解题步骤：
使用输出语句完成打印 左边的中括号”[”
使用循环，输出数组元素值。输出元素值分为两种情况，如下：
a) 最后一个数组元素，加上一个右边的中括号”]”
b) 非最后一个数组元素，加上一个逗号”,”
/*
* 2.1定义打印数组元素方法,按照给定的格式打印[11, 33, 44, 22, 55]
* 实现步骤：
* 1.定义方法实现数组的遍历
* 2.先打印括号--[
* 3.遍历数组
* 判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号]
* (这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行,
* 否则:输出数组的元素和逗号(这样打印元素,不需要换行,保证元素显示在同一行))
*/
public class ArrayMethodTest {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {11, 33, 44, 22, 55};
print(arr);
}
/*
* 定义方法实现数组的遍历
* 返回值：void
* 参数：数组
*/
public static void print(int[] arr){
//1.打印括号[ 不要换行
System.out.print("[");
//2.遍历数组
for(int i = 0; i < arr.length; i++){
//3.判断是否遍历了数组的最后一个元素,如果是最后一个元素,输出括号]
if(i == arr.length -1){
//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
System.out.print(arr[i] + ",");
}
}
}
}
2.2 数组元素逆序
/*
* 2.2数组元素逆序
* 实现步骤：
* 1.利用for循环,实现数组遍历,遍历过程中,最远端换位
* 2.for的第一项,定义两个变量,判断条件：min <= max,增量min++,max--
* min索引和max索引的元素进行交换
* (使用临时的第三方变量进行换成min索引对应元素,之后在赋值给max索引对应元素)
*/
public class ArrayMethodTest1 {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {11, 33, 44, 22, 55};
//2.先打印一把数组,看数组正常
print(arr);
//3.将数组逆序
reverse(arr);
//4.查看数组逆序后的情况
print(arr);
}
/*
* 定义方法实现数组的遍历
* 返回值：void
* 参数：数组
*/
public static void print(int[] arr){
//1.打印括号[ 不要换行
System.out.print("[");
//2.遍历数组
for(int i = 0; i < arr.length; i++){
//3.判断是否遍历了数组的最后一个元素,如果是最后一个元素,输出括号]
if(i == arr.length -1){
//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
System.out.print(arr[i] + ",");
}
}
}
/*
* 定义方法,实现数组的逆序
* 返回值：void
* 参数:数组
*/
public static void reverse(int[] arr){
//利用循环,实现数组遍历,遍历过程中,最远端换位
//for的第一项,定义两个变量
for (int min = 0,max = arr.length -1; min <= max; min++,max--) {
//对数组中的元素,进行位置交换
//min索引和max索引的元素进行交换
//定义变量,保存min索引
int temp = arr[min];
//max索引上的元素,赋值给min索引
arr[min] = arr[max];
//将临时变量中缓存的数据,赋值给max序列
arr[max] = temp;
}
}
}
2.3 数组元素选择排序
/*
* 数组的排序：一般是升序,元素,从小到大的排列
*
* 两种排序的方式：
* 选择排序:数组的每个元素都进行比较
* 冒泡排序:数组中的相邻元素进行比较
* 规则:比较大小,位置交换
*
*/
public class ArrayMethodTest2 {
public static void main(String[] args) {
//1.给定一个需要排序的数组
int[] arr = {3,1,5,-8,0,9,2};
//2.调用选择排序方法
selectSort(arr);
//3.实现数组的遍历打印
print(arr);
}
/*
* 定义方法实现数组的选择排序
* 返回值：void
* 参数：数组
*/
public static void selectSort(int[] arr){
//外循环,选择排序,外循环需要arr.length-1次数
for(int i = 0; i < arr.length - 1;i++){
//内循环,是每次都在减少,修改变量定义
for(int j = i + 1; j < arr.length;j++){
//数组的元素进行判断,从小到大的顺序,排列的数组中的元素
if(arr[i] > arr[j]){
//数组中元素交换位置
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
/*
* 定义方法实现数组的遍历
* 返回值：void
* 参数：数组
*/
public static void print(int[] arr){
//1.打印括号[ 不要换行
System.out.print("[");
//2.遍历数组
for(int i = 0; i < arr.length; i++){
//3.判断是否遍历了数组的最后一个元素,如果是最后一个元素,输出括号]
if(i == arr.length -1){
//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
System.out.print(arr[i] + ",");
}
}
}
}
2.4 数组元素冒泡排序
/*
* 数组的冒泡排序法:数组的相邻元素进行比较大小,交换位置
* N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i-1)次(i = 0,1,2)
* 所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
* 实现步骤：
* 1.进行外循环,冒泡排序,外循环需要arr.length-1次数
* 2.进行内循环,内循环进行相邻元素大小比较,根据升序交换位置,内循环结束一趟,出来一个最大值
* 等又一次外循环,已经出来的最大的数,就无需进行纳入比较中,但是,其他继续相邻元素比较大小,
* 直至所有最大的数出来
*/
public class ArrayMethodTest3 {
public static void main(String[] args) {
//1.给定一个需要排序的数组
int[] arr = {3,1,5,-8,0,9,2};
//2.调用冒泡排序方法
bubbleSort(arr);
//3.实现数组的遍历打印
print(arr);
}
/*
* 冒泡排序法
* 返回值：void
* 参数：数组
* N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i-1)次 (i = 0,1,2)
*/
public static void bubbleSort(int[] arr){
//1.进行外循环,冒泡排序,外循环需要arr.length-1次数,总共进行N-1趟排序
for(int i = 0; i < arr.length - 1; i++){
//2.进行内循环,内循环进行相邻元素大小比较,每i趟的排序次数为(N-i-1)次
//故内循环：判断条件为：j < arr.length - 1 - i
for(int j = 0; j < arr.length - 1 - i;j++){
//3.根据升序交换位置
if(arr[j] > arr[j+1]){
//4.进行交换数组中的元素位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
/*
* 定义方法实现数组的遍历
* 返回值：void
* 参数：数组
*/
public static void print(int[] arr){
//1.打印括号[ 不要换行
System.out.print("[");
//2.遍历数组
for(int i = 0; i < arr.length; i++){
//3.判断是否遍历了数组的最后一个元素,如果是最后一个元素,输出括号]
if(i == arr.length -1){
//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
System.out.print(arr[i] + ",");
}
}
}
}
2.5 数组元素普通查找
2.6 数组元素二分查找(折半查找)
/*
* 二分查找法：
* 在一个数组中,找到一个元素,是否存在于数组中,如果存在,就返回索引
*实现步骤：
*1.三个指针变量mid min max
*2.进行循环折半：可以折半的条件min <= max (需要用到的循环体是while循环体-因为不知道具体需要多少次遍历)
*3.循环体中,公式计算中间索引
*4.循环体中,让被查找的元素与中间的索引所对应的元素进行比较：
*4.1.key < arr[mid]： max = mid - 1
*4.2.key > arr[mid]: min = mid + 1
*4.3.key == arr[mid]:return mid
*5.若循环体结束,元素没有找到,没有找到索引,需要返回-1,代表元素没有找到
* 普通查询法:
* 找到元素在数组中出现的索引,如果没有这个元素,结果就是负数
*/
public class findArrayTest {
public static void main(String[] args) {
//1.给定一个已经排好序的数组
int[] arr = {1,2,3,4,5};
//2.调用二分查找法
int index = binarySearch(arr,4);
if(index != -1){
System.out.println("数组中查找到该元素,该元素的索引为:" + index);
}else{
System.out.println("数组中没有找到该元素！");
}
//3.普通查询
int index1 = search(arr,4);
if(index1 != -1){
System.out.println("数组中查找到该元素,该元素的索引为:" + index1);
}else{
System.out.println("数组中没有找到该元素！");
}
}
/*
* 定义方法,实现折半查找
* 返回值:索引
* 参数：数组,需要查找的元素
*/
public static int binarySearch(int[] arr,int key){
//1.三个指针变量mid min max
int min = 0;
int max = arr.length - 1;
int mid = 0;
//2.进行循环折半：可以折半的条件min <= max (需要用到的循环体是while循环体-因为不知道具体需要多少次遍历)
while(min <= max){
//3 公式计算中间索引
mid = (min + max) / 2;
//4.循环体中,让被查找的元素与中间的索引所对应的元素进行比较：
if(key < arr[mid]){
//4.1.key < arr[mid]： max = mid - 1
max = mid - 1;
}else if(key > arr[mid]){
//4.2.key > arr[mid]: min = mid + 1
min = mid + 1;
}else{
//4.3.key == arr[mid]:return mid
return mid;
}
}
//5.循环体结束,元素没有找到,需要返回-1,代表元素没有找到
return -1;
}
/*
* 定义方法，实现数组的普通查询
* 返回值:索引int
* 参数:数组,查找的元素
* 实现步骤：
* 1.for循环遍历数组
* 2.遍历过程中,遍历数组中的元素与查找的元素进行比较
* 符合:返回索引
* 不符合:继续遍历数组,直至结束
* 3.若遍历结束,没有找到索引,返回-1,代表数组中没有该元素
*/
public static int search(int[] arr,int key){
//1.for循环遍历数组
for (int i = 0; i < arr.length; i++) {
//2.遍历过程中,遍历数组中的元素与查找的元素进行比较
if(arr[i] == key){
return i;
}
}
//3.若遍历结束,没有找到索引,返回-1,代表数组中没有该元素
return -1;
}
}
总结
以上是生活随笔为你收集整理的将四个整数进行从小到大的顺序排列 java_07_Java基础语法_第7天（练习）_讲义(练习加强+在eclipse中实现)...的全部内容，希望文章能够帮你解决所遇到的问题。
- 上一篇： java水晶报表pull模式_水晶报表p
- 下一篇： java web 笔试 题_JavaWe